AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
386ff6e5d6
v8/test/cctest/compiler/test-run-machops.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

7067 lines
220 KiB
C++
Raw Normal View History

Removed the dependency of the test RunComputedCodeObject from RawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1423923003 Cr-Commit-Position: refs/heads/master@{#31586}
2015-10-27 00:37:27 +00:00
// Copyright 2014 the V8 project authors. All rights reserved. Use of this
// source code is governed by a BSD-style license that can be found in the
// LICENSE file.
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
#include <cmath>
[arm] Add support for ROR. Refactor operand2 handling. This was the last missing bit for full "flexible second operand" / operand2 support on ARM. TEST=cctest/test-instruction-selector-arm,cctest/test-run-machops R=jarin@chromium.org Review URL: https://codereview.chromium.org/434553002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22732 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 07:44:29 +00:00
#include <functional>
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
#include <limits>
[turbofan] Introduce WordRor machine operator. Move recognition of rotate-right operations to the MachineOperatorReducer, so we don't need to repeat that in the InstructionSelector for every backend. TEST=base-unittests,compiler-unittests,cctests R=jarin@chromium.org Review URL: https://codereview.chromium.org/469213002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23121 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:07:58 +00:00
#include "src/base/bits.h"
[builtins] Introduce proper base::ieee754::log. This switches Math.log to use an fdlibm based version of log, imported as base::ieee754::log, and use that consistently everywhere, i.e. change the Float64Log TurboFan operators on Intel to use the C++ implementation as well (same for Crankshaft). R=yangguo@chromium.org BUG=v8:5065,v8:5086 Review-Url: https://codereview.chromium.org/2053893003 Cr-Commit-Position: refs/heads/master@{#36880}
2016-06-10 05:51:58 +00:00
#include "src/base/ieee754.h"
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
#include "src/base/overflowing-math.h"
Removed src/{isolate,property-details,utils}-inl.h Baby steps towards saner #includes... Review URL: https://codereview.chromium.org/1051393003 Cr-Commit-Position: refs/heads/master@{#27958}
2015-04-21 10:21:50 +00:00
#include "src/base/utils/random-number-generator.h"
Move utility code to src/utils NOPRESUBMIT=true TBR=mstarzinger@chromium.org Bug: v8:9247 Change-Id: I4cd6b79a1c2cba944f6f23caed59d4f1a4ee358b Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1624217 Commit-Queue: Yang Guo <yangguo@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Cr-Commit-Position: refs/heads/master@{#61790}
2019-05-23 13:27:57 +00:00
#include "src/utils/boxed-float.h"
#include "src/utils/utils.h"
Move more relevant files to src/objects TBR=bmeurer@chromium.org,leszeks@chromium.org Bug: v8:9247 Change-Id: I8d14d0192ea8c705f8274e8e61a162531826edb6 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1624220 Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Hannes Payer <hpayer@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#61769}
2019-05-23 08:51:46 +00:00
#include "src/objects/objects-inl.h"
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/codegen-tester.h"
#include "test/cctest/compiler/value-helper.h"
Move compiler cctests into v8::internal::compiler namespace. This moves all cctest files for the compiler to live in the same namespace as the components they are testing. Hence we can avoid the forbidden using directives pulling in entire namespaces. From the Google C++ style guide: "You may not use a using-directive to make all names from a namespace available". This would be covered by presubmit linter checks if build/namespaces were not blacklisted. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1424943004 Cr-Commit-Position: refs/heads/master@{#31671}
2015-10-30 09:16:26 +00:00
namespace v8 {
namespace internal {
namespace compiler {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
[Interpreter] Add support for loading from / storing to outer context variables. Adds support for loading from and storing to outer context variables. Also adds support for declaring functions on contexts and locals. Finally, fixes a couple of issues with StaContextSlot where we weren't emitting the write barrier and therefore would crash in the GC. Also added code so that --print-bytecode will output the function name before the bytecodes, and replaces MachineType with StoreRepresentation in RawMachineAssembler::Store and updates tests. BUG=v8:4280 LOG=N Review URL: https://codereview.chromium.org/1425633002 Cr-Commit-Position: refs/heads/master@{#31584}
2015-10-26 18:11:23 +00:00
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunInt32Add) {
RawMachineAssemblerTester<int32_t> m;
Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1));
m.Return(add);
CHECK_EQ(1, m.Call());
}
MIPS: [turbofan] Add AddInt + WordShl tests to machops cctest file. AddInt + WordShl cases can be optimized on MIPS and this CL contains tests for those special cases. These test also must be passed on other architectures. BUG= Review URL: https://codereview.chromium.org/1867923002 Cr-Commit-Position: refs/heads/master@{#35349}
2016-04-08 09:56:14 +00:00
static int RunInt32AddShift(bool is_left, int32_t add_left, int32_t add_right,
int32_t shift_left, int32_t shit_right) {
RawMachineAssemblerTester<int32_t> m;
Node* shift =
m.Word32Shl(m.Int32Constant(shift_left), m.Int32Constant(shit_right));
Node* add = m.Int32Add(m.Int32Constant(add_left), m.Int32Constant(add_right));
Node* lsa = is_left ? m.Int32Add(shift, add) : m.Int32Add(add, shift);
m.Return(lsa);
return m.Call();
}
TEST(RunInt32AddShift) {
struct Test_case {
int32_t add_left, add_right, shift_left, shit_right, expected;
};
Test_case tc[] = {
{20, 22, 4, 2, 58},
{20, 22, 4, 1, 50},
{20, 22, 1, 6, 106},
{INT_MAX - 2, 1, 1, 1, INT_MIN}, // INT_MAX - 2 + 1 + (1 << 1), overflow.
};
const size_t tc_size = sizeof(tc) / sizeof(Test_case);
for (size_t i = 0; i < tc_size; ++i) {
CHECK_EQ(tc[i].expected,
RunInt32AddShift(false, tc[i].add_left, tc[i].add_right,
tc[i].shift_left, tc[i].shit_right));
CHECK_EQ(tc[i].expected,
RunInt32AddShift(true, tc[i].add_left, tc[i].add_right,
tc[i].shift_left, tc[i].shit_right));
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
TEST(RunWord32ReverseBits) {
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
if (!m.machine()->Word32ReverseBits().IsSupported()) {
// We can only test the operator if it exists on the testing platform.
return;
}
m.Return(m.AddNode(m.machine()->Word32ReverseBits().op(), m.Parameter(0)));
CHECK_EQ(uint32_t(0x00000000), m.Call(uint32_t(0x00000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint32_t(0x12345678), m.Call(uint32_t(0x1E6A2C48)));
CHECK_EQ(uint32_t(0xFEDCBA09), m.Call(uint32_t(0x905D3B7F)));
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
CHECK_EQ(uint32_t(0x01010101), m.Call(uint32_t(0x80808080)));
CHECK_EQ(uint32_t(0x01020408), m.Call(uint32_t(0x10204080)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint32_t(0xF0703010), m.Call(uint32_t(0x080C0E0F)));
CHECK_EQ(uint32_t(0x1F8D0A3A), m.Call(uint32_t(0x5C50B1F8)));
CHECK_EQ(uint32_t(0xFFFFFFFF), m.Call(uint32_t(0xFFFFFFFF)));
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
}
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
TEST(RunWord32ReverseBytes) {
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[turbofan] Further optimize DataView accesses. This adds support for unaligned load/store access to the DataView backing store and uses byteswap operations to fix up the endianess when necessary. This changes the Word32ReverseBytes operator to be a required operator and adds the missing support on the Intel and ARM platforms (on 64-bit platforms the Word64ReverseBytes operator is also mandatory now). This further improves the performance on the dataviewperf.js test mentioned in the tracking bug by up to 40%, and at the same time reduces the code complexity in the EffectControlLinearizer. Bug: chromium:225811 Change-Id: I7c1ec826faf46a144a5a9068f8f815a5fd040997 Reviewed-on: https://chromium-review.googlesource.com/1174252 Reviewed-by: Sigurd Schneider <sigurds@chromium.org> Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Cr-Commit-Position: refs/heads/master@{#55111}
2018-08-14 08:39:05 +00:00
m.Return(m.AddNode(m.machine()->Word32ReverseBytes(), m.Parameter(0)));
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
CHECK_EQ(uint32_t(0x00000000), m.Call(uint32_t(0x00000000)));
CHECK_EQ(uint32_t(0x12345678), m.Call(uint32_t(0x78563412)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint32_t(0xFEDCBA09), m.Call(uint32_t(0x09BADCFE)));
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
CHECK_EQ(uint32_t(0x01010101), m.Call(uint32_t(0x01010101)));
CHECK_EQ(uint32_t(0x01020408), m.Call(uint32_t(0x08040201)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint32_t(0xF0703010), m.Call(uint32_t(0x103070F0)));
CHECK_EQ(uint32_t(0x1F8D0A3A), m.Call(uint32_t(0x3A0A8D1F)));
CHECK_EQ(uint32_t(0xFFFFFFFF), m.Call(uint32_t(0xFFFFFFFF)));
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
}
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
TEST(RunWord32Ctz) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
if (!m.machine()->Word32Ctz().IsSupported()) {
// We can only test the operator if it exists on the testing platform.
return;
}
m.Return(m.AddNode(m.machine()->Word32Ctz().op(), m.Parameter(0)));
CHECK_EQ(32, m.Call(uint32_t(0x00000000)));
CHECK_EQ(31, m.Call(uint32_t(0x80000000)));
CHECK_EQ(30, m.Call(uint32_t(0x40000000)));
CHECK_EQ(29, m.Call(uint32_t(0x20000000)));
CHECK_EQ(28, m.Call(uint32_t(0x10000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(27, m.Call(uint32_t(0xA8000000)));
CHECK_EQ(26, m.Call(uint32_t(0xF4000000)));
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
CHECK_EQ(25, m.Call(uint32_t(0x62000000)));
CHECK_EQ(24, m.Call(uint32_t(0x91000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(23, m.Call(uint32_t(0xCD800000)));
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
CHECK_EQ(22, m.Call(uint32_t(0x09400000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(21, m.Call(uint32_t(0xAF200000)));
CHECK_EQ(20, m.Call(uint32_t(0xAC100000)));
CHECK_EQ(19, m.Call(uint32_t(0xE0B80000)));
CHECK_EQ(18, m.Call(uint32_t(0x9CE40000)));
CHECK_EQ(17, m.Call(uint32_t(0xC7920000)));
CHECK_EQ(16, m.Call(uint32_t(0xB8F10000)));
CHECK_EQ(15, m.Call(uint32_t(0x3B9F8000)));
CHECK_EQ(14, m.Call(uint32_t(0xDB4C4000)));
CHECK_EQ(13, m.Call(uint32_t(0xE9A32000)));
CHECK_EQ(12, m.Call(uint32_t(0xFCA61000)));
CHECK_EQ(11, m.Call(uint32_t(0x6C8A7800)));
CHECK_EQ(10, m.Call(uint32_t(0x8CE5A400)));
CHECK_EQ(9, m.Call(uint32_t(0xCB7D0200)));
CHECK_EQ(8, m.Call(uint32_t(0xCB4DC100)));
CHECK_EQ(7, m.Call(uint32_t(0xDFBEC580)));
CHECK_EQ(6, m.Call(uint32_t(0x27A9DB40)));
CHECK_EQ(5, m.Call(uint32_t(0xDE3BCB20)));
CHECK_EQ(4, m.Call(uint32_t(0xD7E8A610)));
CHECK_EQ(3, m.Call(uint32_t(0x9AFDBC88)));
CHECK_EQ(2, m.Call(uint32_t(0x9AFDBC84)));
CHECK_EQ(1, m.Call(uint32_t(0x9AFDBC82)));
CHECK_EQ(0, m.Call(uint32_t(0x9AFDBC81)));
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
}
TEST(RunWord32Clz) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Word32Clz(m.Parameter(0)));
CHECK_EQ(0, m.Call(uint32_t(0x80001000)));
CHECK_EQ(1, m.Call(uint32_t(0x40000500)));
CHECK_EQ(2, m.Call(uint32_t(0x20000300)));
CHECK_EQ(3, m.Call(uint32_t(0x10000003)));
CHECK_EQ(4, m.Call(uint32_t(0x08050000)));
CHECK_EQ(5, m.Call(uint32_t(0x04006000)));
CHECK_EQ(6, m.Call(uint32_t(0x02000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(7, m.Call(uint32_t(0x010000A0)));
CHECK_EQ(8, m.Call(uint32_t(0x00800C00)));
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
CHECK_EQ(9, m.Call(uint32_t(0x00400000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(10, m.Call(uint32_t(0x0020000D)));
CHECK_EQ(11, m.Call(uint32_t(0x00100F00)));
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
CHECK_EQ(12, m.Call(uint32_t(0x00080000)));
CHECK_EQ(13, m.Call(uint32_t(0x00041000)));
CHECK_EQ(14, m.Call(uint32_t(0x00020020)));
CHECK_EQ(15, m.Call(uint32_t(0x00010300)));
CHECK_EQ(16, m.Call(uint32_t(0x00008040)));
CHECK_EQ(17, m.Call(uint32_t(0x00004005)));
CHECK_EQ(18, m.Call(uint32_t(0x00002050)));
CHECK_EQ(19, m.Call(uint32_t(0x00001700)));
CHECK_EQ(20, m.Call(uint32_t(0x00000870)));
CHECK_EQ(21, m.Call(uint32_t(0x00000405)));
CHECK_EQ(22, m.Call(uint32_t(0x00000203)));
CHECK_EQ(23, m.Call(uint32_t(0x00000101)));
CHECK_EQ(24, m.Call(uint32_t(0x00000089)));
CHECK_EQ(25, m.Call(uint32_t(0x00000041)));
CHECK_EQ(26, m.Call(uint32_t(0x00000022)));
CHECK_EQ(27, m.Call(uint32_t(0x00000013)));
CHECK_EQ(28, m.Call(uint32_t(0x00000008)));
CHECK_EQ(29, m.Call(uint32_t(0x00000004)));
CHECK_EQ(30, m.Call(uint32_t(0x00000002)));
CHECK_EQ(31, m.Call(uint32_t(0x00000001)));
CHECK_EQ(32, m.Call(uint32_t(0x00000000)));
}
TEST(RunWord32Popcnt) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
if (!m.machine()->Word32Popcnt().IsSupported()) {
// We can only test the operator if it exists on the testing platform.
return;
}
m.Return(m.AddNode(m.machine()->Word32Popcnt().op(), m.Parameter(0)));
CHECK_EQ(0, m.Call(uint32_t(0x00000000)));
CHECK_EQ(1, m.Call(uint32_t(0x00000001)));
CHECK_EQ(1, m.Call(uint32_t(0x80000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(32, m.Call(uint32_t(0xFFFFFFFF)));
CHECK_EQ(6, m.Call(uint32_t(0x000DC100)));
CHECK_EQ(9, m.Call(uint32_t(0xE00DC100)));
CHECK_EQ(11, m.Call(uint32_t(0xE00DC103)));
CHECK_EQ(9, m.Call(uint32_t(0x000DC107)));
Added a test for CLZ Review URL: https://codereview.chromium.org/1397883003 Cr-Commit-Position: refs/heads/master@{#31316}
2015-10-15 18:37:00 +00:00
}
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
#if V8_TARGET_ARCH_64_BIT
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
TEST(RunWord64ReverseBits) {
RawMachineAssemblerTester<uint64_t> m(MachineType::Uint64());
if (!m.machine()->Word64ReverseBits().IsSupported()) {
return;
}
m.Return(m.AddNode(m.machine()->Word64ReverseBits().op(), m.Parameter(0)));
CHECK_EQ(uint64_t(0x0000000000000000), m.Call(uint64_t(0x0000000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint64_t(0x1234567890ABCDEF), m.Call(uint64_t(0xF7B3D5091E6A2C48)));
CHECK_EQ(uint64_t(0xFEDCBA0987654321), m.Call(uint64_t(0x84C2A6E1905D3B7F)));
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
CHECK_EQ(uint64_t(0x0101010101010101), m.Call(uint64_t(0x8080808080808080)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint64_t(0x0102040803060C01), m.Call(uint64_t(0x803060C010204080)));
CHECK_EQ(uint64_t(0xF0703010E060200F), m.Call(uint64_t(0xF0040607080C0E0F)));
CHECK_EQ(uint64_t(0x2F8A6DF01C21FA3B), m.Call(uint64_t(0xDC5F84380FB651F4)));
CHECK_EQ(uint64_t(0xFFFFFFFFFFFFFFFF), m.Call(uint64_t(0xFFFFFFFFFFFFFFFF)));
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
}
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
TEST(RunWord64ReverseBytes) {
BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Uint64());
[turbofan] Further optimize DataView accesses. This adds support for unaligned load/store access to the DataView backing store and uses byteswap operations to fix up the endianess when necessary. This changes the Word32ReverseBytes operator to be a required operator and adds the missing support on the Intel and ARM platforms (on 64-bit platforms the Word64ReverseBytes operator is also mandatory now). This further improves the performance on the dataviewperf.js test mentioned in the tracking bug by up to 40%, and at the same time reduces the code complexity in the EffectControlLinearizer. Bug: chromium:225811 Change-Id: I7c1ec826faf46a144a5a9068f8f815a5fd040997 Reviewed-on: https://chromium-review.googlesource.com/1174252 Reviewed-by: Sigurd Schneider <sigurds@chromium.org> Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Cr-Commit-Position: refs/heads/master@{#55111}
2018-08-14 08:39:05 +00:00
m.Return(m.AddNode(m.machine()->Word64ReverseBytes(), m.Parameter(0)));
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
CHECK_EQ(uint64_t(0x0000000000000000), m.Call(uint64_t(0x0000000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint64_t(0x1234567890ABCDEF), m.Call(uint64_t(0xEFCDAB9078563412)));
CHECK_EQ(uint64_t(0xFEDCBA0987654321), m.Call(uint64_t(0x2143658709BADCFE)));
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
CHECK_EQ(uint64_t(0x0101010101010101), m.Call(uint64_t(0x0101010101010101)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(uint64_t(0x0102040803060C01), m.Call(uint64_t(0x010C060308040201)));
CHECK_EQ(uint64_t(0xF0703010E060200F), m.Call(uint64_t(0x0F2060E0103070F0)));
CHECK_EQ(uint64_t(0x2F8A6DF01C21FA3B), m.Call(uint64_t(0x3BFA211CF06D8A2F)));
CHECK_EQ(uint64_t(0xFFFFFFFFFFFFFFFF), m.Call(uint64_t(0xFFFFFFFFFFFFFFFF)));
[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode This commit fixes wasm little-endian load issue on big-endian platform by introducing reverse byte operation immediately after a load. R=bmeurer@chromium.org, titzer@chromium.org BUG= Review-Url: https://codereview.chromium.org/2045943002 Cr-Commit-Position: refs/heads/master@{#38183}
2016-07-29 19:31:54 +00:00
}
Added a ReverseBits operator and used it to implement Ctz. Let me know if this is not the right approach Review URL: https://codereview.chromium.org/1698483002 Cr-Commit-Position: refs/heads/master@{#34028}
2016-02-16 11:14:01 +00:00
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
TEST(RunWord64Clz) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
m.Return(m.Word64Clz(m.Parameter(0)));
CHECK_EQ(0, m.Call(uint64_t(0x8000100000000000)));
CHECK_EQ(1, m.Call(uint64_t(0x4000050000000000)));
CHECK_EQ(2, m.Call(uint64_t(0x2000030000000000)));
CHECK_EQ(3, m.Call(uint64_t(0x1000000300000000)));
CHECK_EQ(4, m.Call(uint64_t(0x0805000000000000)));
CHECK_EQ(5, m.Call(uint64_t(0x0400600000000000)));
CHECK_EQ(6, m.Call(uint64_t(0x0200000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(7, m.Call(uint64_t(0x010000A000000000)));
CHECK_EQ(8, m.Call(uint64_t(0x00800C0000000000)));
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
CHECK_EQ(9, m.Call(uint64_t(0x0040000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(10, m.Call(uint64_t(0x0020000D00000000)));
CHECK_EQ(11, m.Call(uint64_t(0x00100F0000000000)));
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
CHECK_EQ(12, m.Call(uint64_t(0x0008000000000000)));
CHECK_EQ(13, m.Call(uint64_t(0x0004100000000000)));
CHECK_EQ(14, m.Call(uint64_t(0x0002002000000000)));
CHECK_EQ(15, m.Call(uint64_t(0x0001030000000000)));
CHECK_EQ(16, m.Call(uint64_t(0x0000804000000000)));
CHECK_EQ(17, m.Call(uint64_t(0x0000400500000000)));
CHECK_EQ(18, m.Call(uint64_t(0x0000205000000000)));
CHECK_EQ(19, m.Call(uint64_t(0x0000170000000000)));
CHECK_EQ(20, m.Call(uint64_t(0x0000087000000000)));
CHECK_EQ(21, m.Call(uint64_t(0x0000040500000000)));
CHECK_EQ(22, m.Call(uint64_t(0x0000020300000000)));
CHECK_EQ(23, m.Call(uint64_t(0x0000010100000000)));
CHECK_EQ(24, m.Call(uint64_t(0x0000008900000000)));
CHECK_EQ(25, m.Call(uint64_t(0x0000004100000000)));
CHECK_EQ(26, m.Call(uint64_t(0x0000002200000000)));
CHECK_EQ(27, m.Call(uint64_t(0x0000001300000000)));
CHECK_EQ(28, m.Call(uint64_t(0x0000000800000000)));
CHECK_EQ(29, m.Call(uint64_t(0x0000000400000000)));
CHECK_EQ(30, m.Call(uint64_t(0x0000000200000000)));
CHECK_EQ(31, m.Call(uint64_t(0x0000000100000000)));
CHECK_EQ(32, m.Call(uint64_t(0x0000000080001000)));
CHECK_EQ(33, m.Call(uint64_t(0x0000000040000500)));
CHECK_EQ(34, m.Call(uint64_t(0x0000000020000300)));
CHECK_EQ(35, m.Call(uint64_t(0x0000000010000003)));
CHECK_EQ(36, m.Call(uint64_t(0x0000000008050000)));
CHECK_EQ(37, m.Call(uint64_t(0x0000000004006000)));
CHECK_EQ(38, m.Call(uint64_t(0x0000000002000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(39, m.Call(uint64_t(0x00000000010000A0)));
CHECK_EQ(40, m.Call(uint64_t(0x0000000000800C00)));
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
CHECK_EQ(41, m.Call(uint64_t(0x0000000000400000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(42, m.Call(uint64_t(0x000000000020000D)));
CHECK_EQ(43, m.Call(uint64_t(0x0000000000100F00)));
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
CHECK_EQ(44, m.Call(uint64_t(0x0000000000080000)));
CHECK_EQ(45, m.Call(uint64_t(0x0000000000041000)));
CHECK_EQ(46, m.Call(uint64_t(0x0000000000020020)));
CHECK_EQ(47, m.Call(uint64_t(0x0000000000010300)));
CHECK_EQ(48, m.Call(uint64_t(0x0000000000008040)));
CHECK_EQ(49, m.Call(uint64_t(0x0000000000004005)));
CHECK_EQ(50, m.Call(uint64_t(0x0000000000002050)));
CHECK_EQ(51, m.Call(uint64_t(0x0000000000001700)));
CHECK_EQ(52, m.Call(uint64_t(0x0000000000000870)));
CHECK_EQ(53, m.Call(uint64_t(0x0000000000000405)));
CHECK_EQ(54, m.Call(uint64_t(0x0000000000000203)));
CHECK_EQ(55, m.Call(uint64_t(0x0000000000000101)));
CHECK_EQ(56, m.Call(uint64_t(0x0000000000000089)));
CHECK_EQ(57, m.Call(uint64_t(0x0000000000000041)));
CHECK_EQ(58, m.Call(uint64_t(0x0000000000000022)));
CHECK_EQ(59, m.Call(uint64_t(0x0000000000000013)));
CHECK_EQ(60, m.Call(uint64_t(0x0000000000000008)));
CHECK_EQ(61, m.Call(uint64_t(0x0000000000000004)));
CHECK_EQ(62, m.Call(uint64_t(0x0000000000000002)));
CHECK_EQ(63, m.Call(uint64_t(0x0000000000000001)));
CHECK_EQ(64, m.Call(uint64_t(0x0000000000000000)));
}
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
TEST(RunWord64Ctz) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
if (!m.machine()->Word64Ctz().IsSupported()) {
return;
}
m.Return(m.AddNode(m.machine()->Word64Ctz().op(), m.Parameter(0)));
CHECK_EQ(64, m.Call(uint64_t(0x0000000000000000)));
CHECK_EQ(63, m.Call(uint64_t(0x8000000000000000)));
CHECK_EQ(62, m.Call(uint64_t(0x4000000000000000)));
CHECK_EQ(61, m.Call(uint64_t(0x2000000000000000)));
CHECK_EQ(60, m.Call(uint64_t(0x1000000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(59, m.Call(uint64_t(0xA800000000000000)));
CHECK_EQ(58, m.Call(uint64_t(0xF400000000000000)));
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
CHECK_EQ(57, m.Call(uint64_t(0x6200000000000000)));
CHECK_EQ(56, m.Call(uint64_t(0x9100000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(55, m.Call(uint64_t(0xCD80000000000000)));
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
CHECK_EQ(54, m.Call(uint64_t(0x0940000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(53, m.Call(uint64_t(0xAF20000000000000)));
CHECK_EQ(52, m.Call(uint64_t(0xAC10000000000000)));
CHECK_EQ(51, m.Call(uint64_t(0xE0B8000000000000)));
CHECK_EQ(50, m.Call(uint64_t(0x9CE4000000000000)));
CHECK_EQ(49, m.Call(uint64_t(0xC792000000000000)));
CHECK_EQ(48, m.Call(uint64_t(0xB8F1000000000000)));
CHECK_EQ(47, m.Call(uint64_t(0x3B9F800000000000)));
CHECK_EQ(46, m.Call(uint64_t(0xDB4C400000000000)));
CHECK_EQ(45, m.Call(uint64_t(0xE9A3200000000000)));
CHECK_EQ(44, m.Call(uint64_t(0xFCA6100000000000)));
CHECK_EQ(43, m.Call(uint64_t(0x6C8A780000000000)));
CHECK_EQ(42, m.Call(uint64_t(0x8CE5A40000000000)));
CHECK_EQ(41, m.Call(uint64_t(0xCB7D020000000000)));
CHECK_EQ(40, m.Call(uint64_t(0xCB4DC10000000000)));
CHECK_EQ(39, m.Call(uint64_t(0xDFBEC58000000000)));
CHECK_EQ(38, m.Call(uint64_t(0x27A9DB4000000000)));
CHECK_EQ(37, m.Call(uint64_t(0xDE3BCB2000000000)));
CHECK_EQ(36, m.Call(uint64_t(0xD7E8A61000000000)));
CHECK_EQ(35, m.Call(uint64_t(0x9AFDBC8800000000)));
CHECK_EQ(34, m.Call(uint64_t(0x9AFDBC8400000000)));
CHECK_EQ(33, m.Call(uint64_t(0x9AFDBC8200000000)));
CHECK_EQ(32, m.Call(uint64_t(0x9AFDBC8100000000)));
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
CHECK_EQ(31, m.Call(uint64_t(0x0000000080000000)));
CHECK_EQ(30, m.Call(uint64_t(0x0000000040000000)));
CHECK_EQ(29, m.Call(uint64_t(0x0000000020000000)));
CHECK_EQ(28, m.Call(uint64_t(0x0000000010000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(27, m.Call(uint64_t(0x00000000A8000000)));
CHECK_EQ(26, m.Call(uint64_t(0x00000000F4000000)));
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
CHECK_EQ(25, m.Call(uint64_t(0x0000000062000000)));
CHECK_EQ(24, m.Call(uint64_t(0x0000000091000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(23, m.Call(uint64_t(0x00000000CD800000)));
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
CHECK_EQ(22, m.Call(uint64_t(0x0000000009400000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(21, m.Call(uint64_t(0x00000000AF200000)));
CHECK_EQ(20, m.Call(uint64_t(0x00000000AC100000)));
CHECK_EQ(19, m.Call(uint64_t(0x00000000E0B80000)));
CHECK_EQ(18, m.Call(uint64_t(0x000000009CE40000)));
CHECK_EQ(17, m.Call(uint64_t(0x00000000C7920000)));
CHECK_EQ(16, m.Call(uint64_t(0x00000000B8F10000)));
CHECK_EQ(15, m.Call(uint64_t(0x000000003B9F8000)));
CHECK_EQ(14, m.Call(uint64_t(0x00000000DB4C4000)));
CHECK_EQ(13, m.Call(uint64_t(0x00000000E9A32000)));
CHECK_EQ(12, m.Call(uint64_t(0x00000000FCA61000)));
CHECK_EQ(11, m.Call(uint64_t(0x000000006C8A7800)));
CHECK_EQ(10, m.Call(uint64_t(0x000000008CE5A400)));
CHECK_EQ(9, m.Call(uint64_t(0x00000000CB7D0200)));
CHECK_EQ(8, m.Call(uint64_t(0x00000000CB4DC100)));
CHECK_EQ(7, m.Call(uint64_t(0x00000000DFBEC580)));
CHECK_EQ(6, m.Call(uint64_t(0x0000000027A9DB40)));
CHECK_EQ(5, m.Call(uint64_t(0x00000000DE3BCB20)));
CHECK_EQ(4, m.Call(uint64_t(0x00000000D7E8A610)));
CHECK_EQ(3, m.Call(uint64_t(0x000000009AFDBC88)));
CHECK_EQ(2, m.Call(uint64_t(0x000000009AFDBC84)));
CHECK_EQ(1, m.Call(uint64_t(0x000000009AFDBC82)));
CHECK_EQ(0, m.Call(uint64_t(0x000000009AFDBC81)));
Implemented the ctz Turbo Fan operator for x64. Ctz is implemented as an optional operator at the moment, which is only implemented by x64 at the moment. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1421163005 Cr-Commit-Position: refs/heads/master@{#31912}
2015-11-10 08:42:17 +00:00
}
Implemented the Word64Popcnt TurboFan operator for x64. Popcnt is implemented as an optional operator, which is only implementd by x64 at the moment. Review URL: https://codereview.chromium.org/1424173006 Cr-Commit-Position: refs/heads/master@{#31928}
2015-11-10 20:38:02 +00:00
TEST(RunWord64Popcnt) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
Implemented the Word64Popcnt TurboFan operator for x64. Popcnt is implemented as an optional operator, which is only implementd by x64 at the moment. Review URL: https://codereview.chromium.org/1424173006 Cr-Commit-Position: refs/heads/master@{#31928}
2015-11-10 20:38:02 +00:00
if (!m.machine()->Word64Popcnt().IsSupported()) {
return;
}
m.Return(m.AddNode(m.machine()->Word64Popcnt().op(), m.Parameter(0)));
CHECK_EQ(0, m.Call(uint64_t(0x0000000000000000)));
CHECK_EQ(1, m.Call(uint64_t(0x0000000000000001)));
CHECK_EQ(1, m.Call(uint64_t(0x8000000000000000)));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
CHECK_EQ(64, m.Call(uint64_t(0xFFFFFFFFFFFFFFFF)));
CHECK_EQ(12, m.Call(uint64_t(0x000DC100000DC100)));
CHECK_EQ(18, m.Call(uint64_t(0xE00DC100E00DC100)));
CHECK_EQ(22, m.Call(uint64_t(0xE00DC103E00DC103)));
CHECK_EQ(18, m.Call(uint64_t(0x000DC107000DC107)));
Implemented the Word64Popcnt TurboFan operator for x64. Popcnt is implemented as an optional operator, which is only implementd by x64 at the moment. Review URL: https://codereview.chromium.org/1424173006 Cr-Commit-Position: refs/heads/master@{#31928}
2015-11-10 20:38:02 +00:00
}
[Turbofan][ptr-compr] Handle "compress changes" in the instruction selector Said instructions look like ChangeTaggedXXXToCompressedXXX and ChangeCompressedXXXToTaggedXXX for XXX in ("", "Pointer", "Signed"). This change only affects 64 bit architectures (both for x64 and arm64). Also added tests for the machine operators. Cq-Include-Trybots: luci.v8.try:v8_linux64_pointer_compression_rel_ng,v8_linux64_arm64_pointer_compression_rel_ng Bug: v8:8977 Change-Id: I239d9de7f214424852e75b5d56996e8dfdacd400 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1526009 Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Reviewed-by: Michael Stanton <mvstanton@chromium.org> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Cr-Commit-Position: refs/heads/master@{#60393}
2019-03-21 10:20:00 +00:00
#ifdef V8_COMPRESS_POINTERS
TEST(CompressDecompressTaggedAnyPointer) {
RawMachineAssemblerTester<void*> m;
Handle<HeapNumber> value = m.isolate()->factory()->NewHeapNumber(11.2);
Node* node = m.HeapConstant(value);
m.Return(m.ChangeCompressedToTagged(m.ChangeTaggedToCompressed(node)));
HeapObject result =
HeapObject::cast(Object(reinterpret_cast<Address>(m.Call())));
CHECK_EQ(result, *value);
}
TEST(CompressDecompressTaggedAnySigned) {
RawMachineAssemblerTester<int64_t> m;
Smi smi = Smi::FromInt(123);
int64_t smiPointer = static_cast<int64_t>(smi.ptr());
Node* node = m.Int64Constant(smiPointer);
m.Return(m.ChangeCompressedToTagged(m.ChangeTaggedToCompressed(node)));
CHECK_EQ(smiPointer, m.Call());
}
TEST(CompressDecompressTaggedPointer) {
RawMachineAssemblerTester<void*> m;
Handle<HeapNumber> value = m.isolate()->factory()->NewHeapNumber(11.2);
Node* node = m.HeapConstant(value);
m.Return(m.ChangeCompressedPointerToTaggedPointer(
m.ChangeTaggedPointerToCompressedPointer(node)));
HeapObject result =
HeapObject::cast(Object(reinterpret_cast<Address>(m.Call())));
CHECK_EQ(result, *value);
}
TEST(CompressDecompressTaggedSigned) {
RawMachineAssemblerTester<int64_t> m;
Smi smi = Smi::FromInt(123);
int64_t smiPointer = static_cast<int64_t>(smi.ptr());
Node* node = m.Int64Constant(smiPointer);
m.Return(m.ChangeCompressedSignedToTaggedSigned(
m.ChangeTaggedSignedToCompressedSigned(node)));
CHECK_EQ(smiPointer, m.Call());
}
#endif // V8_COMPRESS_POINTERS
Implemented the Word64Clz TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1413463009 Cr-Commit-Position: refs/heads/master@{#31858}
2015-11-06 14:50:44 +00:00
#endif // V8_TARGET_ARCH_64_BIT
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
static Node* Int32Input(RawMachineAssemblerTester<int32_t>* m, int index) {
switch (index) {
case 0:
return m->Parameter(0);
case 1:
return m->Parameter(1);
case 2:
return m->Int32Constant(0);
case 3:
return m->Int32Constant(1);
case 4:
return m->Int32Constant(-1);
case 5:
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
return m->Int32Constant(0xFF);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
case 6:
return m->Int32Constant(0x01234567);
case 7:
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
return m->Load(MachineType::Int32(), m->PointerConstant(nullptr));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
default:
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
return nullptr;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
TEST(CodeGenInt32Binop) {
RawMachineAssemblerTester<void> m;
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
const Operator* kOps[] = {
[turbofan] Also optimize unsigned division by constant. TEST=cctest,mjsunit,unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/697663003 Cr-Commit-Position: refs/heads/master@{#25061} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25061 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-11-03 10:04:37 +00:00
m.machine()->Word32And(), m.machine()->Word32Or(),
m.machine()->Word32Xor(), m.machine()->Word32Shl(),
m.machine()->Word32Shr(), m.machine()->Word32Sar(),
m.machine()->Word32Equal(), m.machine()->Int32Add(),
m.machine()->Int32Sub(), m.machine()->Int32Mul(),
m.machine()->Int32MulHigh(), m.machine()->Int32Div(),
m.machine()->Uint32Div(), m.machine()->Int32Mod(),
m.machine()->Uint32Mod(), m.machine()->Uint32MulHigh(),
m.machine()->Int32LessThan(), m.machine()->Int32LessThanOrEqual(),
m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual()};
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
for (size_t i = 0; i < arraysize(kOps); ++i) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 8; k++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* a = Int32Input(&m, j);
Node* b = Int32Input(&m, k);
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.Return(m.AddNode(kOps[i], a, b));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.GenerateCode();
}
}
}
}
[turbofan] Handle void returns in instruction selector. R=jarin@chromium.org BUG= Review URL: https://codereview.chromium.org/1269183002 Cr-Commit-Position: refs/heads/master@{#29999}
2015-08-04 13:13:54 +00:00
TEST(CodeGenNop) {
RawMachineAssemblerTester<void> m;
m.Return(m.Int32Constant(0));
m.GenerateCode();
}
[turbofan] Drop V8_TURBOFAN_BACKEND and V8_TURBOFAN_TARGET defines. TurboFan is now a requirement and supported by all backends, so we don't need those macros (plus all the machinery on top) anymore. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1282763002 Cr-Commit-Position: refs/heads/master@{#30082}
2015-08-10 07:17:16 +00:00
#if V8_TARGET_ARCH_64_BIT
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
static Node* Int64Input(RawMachineAssemblerTester<int64_t>* m, int index) {
switch (index) {
case 0:
return m->Parameter(0);
case 1:
return m->Parameter(1);
case 2:
return m->Int64Constant(0);
case 3:
return m->Int64Constant(1);
case 4:
return m->Int64Constant(-1);
case 5:
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
return m->Int64Constant(0xFF);
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
case 6:
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
return m->Int64Constant(0x0123456789ABCDEFLL);
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
case 7:
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
return m->Load(MachineType::Int64(), m->PointerConstant(nullptr));
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
default:
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
return nullptr;
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
}
}
TEST(CodeGenInt64Binop) {
RawMachineAssemblerTester<void> m;
const Operator* kOps[] = {
m.machine()->Word64And(), m.machine()->Word64Or(),
m.machine()->Word64Xor(), m.machine()->Word64Shl(),
m.machine()->Word64Shr(), m.machine()->Word64Sar(),
m.machine()->Word64Equal(), m.machine()->Int64Add(),
m.machine()->Int64Sub(), m.machine()->Int64Mul(), m.machine()->Int64Div(),
m.machine()->Uint64Div(), m.machine()->Int64Mod(),
m.machine()->Uint64Mod(), m.machine()->Int64LessThan(),
m.machine()->Int64LessThanOrEqual(), m.machine()->Uint64LessThan(),
m.machine()->Uint64LessThanOrEqual()};
for (size_t i = 0; i < arraysize(kOps); ++i) {
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 8; k++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int64_t> m(MachineType::Int64(),
MachineType::Int64());
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
Node* a = Int64Input(&m, j);
Node* b = Int64Input(&m, k);
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.Return(m.AddNode(kOps[i], a, b));
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
m.GenerateCode();
}
}
}
}
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
TEST(RunInt64AddWithOverflowP) {
int64_t actual_val = -1;
RawMachineAssemblerTester<int32_t> m;
Int64BinopTester bt(&m);
Node* add = m.Int64AddWithOverflow(bt.param0, bt.param1);
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
bt.AddReturn(ovf);
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
int64_t expected_val;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow64(i, j, &expected_val);
CHECK_EQ(expected_ovf, bt.call(i, j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt64AddWithOverflowImm) {
int64_t actual_val = -1, expected_val = 0;
FOR_INT64_INPUTS(i) {
{
RawMachineAssemblerTester<int32_t> m(MachineType::Int64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int64AddWithOverflow(m.Int64Constant(i), m.Parameter(0));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
m.Return(ovf);
FOR_INT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow64(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
{
RawMachineAssemblerTester<int32_t> m(MachineType::Int64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int64AddWithOverflow(m.Parameter(0), m.Int64Constant(i));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
m.Return(ovf);
FOR_INT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow64(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
FOR_INT64_INPUTS(j) {
RawMachineAssemblerTester<int32_t> m;
Node* add =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int64AddWithOverflow(m.Int64Constant(i), m.Int64Constant(j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
m.Return(ovf);
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow64(i, j, &expected_val);
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_ovf, m.Call());
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt64AddWithOverflowInBranchP) {
int constant = 911777;
RawMachineLabel blocka, blockb;
RawMachineAssemblerTester<int32_t> m;
Int64BinopTester bt(&m);
Node* add = m.Int64AddWithOverflow(bt.param0, bt.param1);
Node* ovf = m.Projection(1, add);
m.Branch(ovf, &blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int64Constant(constant));
m.Bind(&blockb);
Node* val = m.Projection(0, add);
Node* truncated = m.TruncateInt64ToInt32(val);
bt.AddReturn(truncated);
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
int32_t expected = constant;
int64_t result;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (!base::bits::SignedAddOverflow64(i, j, &result)) {
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
expected = static_cast<int32_t>(result);
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_EQ(expected, bt.call(i, j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
}
}
}
TEST(RunInt64SubWithOverflowP) {
int64_t actual_val = -1;
RawMachineAssemblerTester<int32_t> m;
Int64BinopTester bt(&m);
Node* add = m.Int64SubWithOverflow(bt.param0, bt.param1);
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
bt.AddReturn(ovf);
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
int64_t expected_val;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow64(i, j, &expected_val);
CHECK_EQ(expected_ovf, bt.call(i, j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt64SubWithOverflowImm) {
int64_t actual_val = -1, expected_val = 0;
FOR_INT64_INPUTS(i) {
{
RawMachineAssemblerTester<int32_t> m(MachineType::Int64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int64SubWithOverflow(m.Int64Constant(i), m.Parameter(0));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
m.Return(ovf);
FOR_INT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow64(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
{
RawMachineAssemblerTester<int32_t> m(MachineType::Int64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int64SubWithOverflow(m.Parameter(0), m.Int64Constant(i));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
m.Return(ovf);
FOR_INT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow64(j, i, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
FOR_INT64_INPUTS(j) {
RawMachineAssemblerTester<int32_t> m;
Node* add =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int64SubWithOverflow(m.Int64Constant(i), m.Int64Constant(j));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val);
m.Return(ovf);
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow64(i, j, &expected_val);
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
CHECK_EQ(expected_ovf, m.Call());
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt64SubWithOverflowInBranchP) {
int constant = 911999;
RawMachineLabel blocka, blockb;
RawMachineAssemblerTester<int32_t> m;
Int64BinopTester bt(&m);
Node* sub = m.Int64SubWithOverflow(bt.param0, bt.param1);
Node* ovf = m.Projection(1, sub);
m.Branch(ovf, &blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int64Constant(constant));
m.Bind(&blockb);
Node* val = m.Projection(0, sub);
Node* truncated = m.TruncateInt64ToInt32(val);
bt.AddReturn(truncated);
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
int32_t expected = constant;
int64_t result;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (!base::bits::SignedSubOverflow64(i, j, &result)) {
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
expected = static_cast<int32_t>(result);
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_EQ(expected, static_cast<int32_t>(bt.call(i, j)));
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
}
}
}
MIPS: [turbofan] Add AddInt + WordShl tests to machops cctest file. AddInt + WordShl cases can be optimized on MIPS and this CL contains tests for those special cases. These test also must be passed on other architectures. BUG= Review URL: https://codereview.chromium.org/1867923002 Cr-Commit-Position: refs/heads/master@{#35349}
2016-04-08 09:56:14 +00:00
static int64_t RunInt64AddShift(bool is_left, int64_t add_left,
int64_t add_right, int64_t shift_left,
int64_t shit_right) {
RawMachineAssemblerTester<int64_t> m;
Node* shift = m.Word64Shl(m.Int64Constant(4), m.Int64Constant(2));
Node* add = m.Int64Add(m.Int64Constant(20), m.Int64Constant(22));
Node* dlsa = is_left ? m.Int64Add(shift, add) : m.Int64Add(add, shift);
m.Return(dlsa);
return m.Call();
}
TEST(RunInt64AddShift) {
struct Test_case {
int64_t add_left, add_right, shift_left, shit_right, expected;
};
Test_case tc[] = {
{20, 22, 4, 2, 58},
{20, 22, 4, 1, 50},
{20, 22, 1, 6, 106},
{INT64_MAX - 2, 1, 1, 1,
INT64_MIN}, // INT64_MAX - 2 + 1 + (1 << 1), overflow.
};
const size_t tc_size = sizeof(tc) / sizeof(Test_case);
for (size_t i = 0; i < tc_size; ++i) {
CHECK_EQ(58, RunInt64AddShift(false, tc[i].add_left, tc[i].add_right,
tc[i].shift_left, tc[i].shit_right));
CHECK_EQ(58, RunInt64AddShift(true, tc[i].add_left, tc[i].add_right,
tc[i].shift_left, tc[i].shit_right));
}
}
[turbofan] Add Int64(Add|Sub)WithOverflow support. Review URL: https://codereview.chromium.org/1544743004 Cr-Commit-Position: refs/heads/master@{#33039}
2015-12-24 18:50:37 +00:00
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
// TODO(titzer): add tests that run 64-bit integer operations.
[turbofan] Drop V8_TURBOFAN_BACKEND and V8_TURBOFAN_TARGET defines. TurboFan is now a requirement and supported by all backends, so we don't need those macros (plus all the machinery on top) anymore. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1282763002 Cr-Commit-Position: refs/heads/master@{#30082}
2015-08-10 07:17:16 +00:00
#endif // V8_TARGET_ARCH_64_BIT
[turbofan] Add Uint64LessThanOrEqual to 64-bit TurboFan backends. Also add control inputs to 64-bit integer divide and modulus operations. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1223613002 Cr-Commit-Position: refs/heads/master@{#29460}
2015-07-03 05:13:57 +00:00
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunGoto) {
RawMachineAssemblerTester<int32_t> m;
int constant = 99999;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel next;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&next);
m.Bind(&next);
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
TEST(RunGotoMultiple) {
RawMachineAssemblerTester<int32_t> m;
int constant = 9999977;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel labels[10];
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t i = 0; i < arraysize(labels); i++) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&labels[i]);
m.Bind(&labels[i]);
}
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
TEST(RunBranch) {
RawMachineAssemblerTester<int32_t> m;
int constant = 999777;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(0 - constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
TEST(RunDiamond2) {
RawMachineAssemblerTester<int32_t> m;
int constant = 995666;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&end);
m.Bind(&blockb);
m.Goto(&end);
m.Bind(&end);
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
TEST(RunLoop) {
RawMachineAssemblerTester<int32_t> m;
int constant = 999555;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, exit;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&header);
m.Bind(&header);
m.Branch(m.Int32Constant(0), &body, &exit);
m.Bind(&body);
m.Goto(&header);
m.Bind(&exit);
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
template <typename R>
static void BuildDiamondPhi(RawMachineAssemblerTester<R>* m, Node* cond_node,
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
MachineRepresentation rep, Node* true_node,
[turbofan] Add MachineType to Phi. TEST=cctest,compiler-unittests,mjsunit R=mstarzinger@chromium.org, titzer@chromium.org Review URL: https://codereview.chromium.org/545153002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23728 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-05 11:44:31 +00:00
Node* false_node) {
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m->Branch(cond_node, &blocka, &blockb);
m->Bind(&blocka);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m->Goto(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m->Bind(&blockb);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m->Goto(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m->Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m->Phi(rep, true_node, false_node);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m->Return(phi);
}
TEST(RunDiamondPhiConst) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int false_val = 0xFF666;
int true_val = 0x00DDD;
Node* true_node = m.Int32Constant(true_val);
Node* false_node = m.Int32Constant(false_val);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kWord32, true_node,
false_node);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(false_val, m.Call(0));
CHECK_EQ(true_val, m.Call(1));
}
TEST(RunDiamondPhiNumber) {
[ubsan] Port Object to the new design Tbr: ahaas@chromium.org,leszeks@chromium.org,verwaest@chromium.org Bug: v8:3770 Change-Id: Ia6530fbb70dac05e9972283781c3550d8b50e1eb Reviewed-on: https://chromium-review.googlesource.com/c/1390116 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Alexei Filippov <alph@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Sigurd Schneider <sigurds@chromium.org> Cr-Commit-Position: refs/heads/master@{#58470}
2018-12-25 00:19:47 +00:00
RawMachineAssemblerTester<Object> m(MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
double false_val = -11.1;
double true_val = 200.1;
Node* true_node = m.NumberConstant(true_val);
Node* false_node = m.NumberConstant(false_val);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kTagged, true_node,
false_node);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.CheckNumber(false_val, m.Call(0));
m.CheckNumber(true_val, m.Call(1));
}
TEST(RunDiamondPhiString) {
[ubsan] Port Object to the new design Tbr: ahaas@chromium.org,leszeks@chromium.org,verwaest@chromium.org Bug: v8:3770 Change-Id: Ia6530fbb70dac05e9972283781c3550d8b50e1eb Reviewed-on: https://chromium-review.googlesource.com/c/1390116 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Alexei Filippov <alph@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Sigurd Schneider <sigurds@chromium.org> Cr-Commit-Position: refs/heads/master@{#58470}
2018-12-25 00:19:47 +00:00
RawMachineAssemblerTester<Object> m(MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
const char* false_val = "false";
const char* true_val = "true";
Node* true_node = m.StringConstant(true_val);
Node* false_node = m.StringConstant(false_val);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kTagged, true_node,
false_node);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.CheckString(false_val, m.Call(0));
m.CheckString(true_val, m.Call(1));
}
TEST(RunDiamondPhiParam) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kWord32,
m.Parameter(1), m.Parameter(2));
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
int32_t c1 = 0x260CB75A;
int32_t c2 = 0xCD3E9C8B;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int result = m.Call(0, c1, c2);
CHECK_EQ(c2, result);
result = m.Call(1, c1, c2);
CHECK_EQ(c1, result);
}
TEST(RunLoopPhiConst) {
RawMachineAssemblerTester<int32_t> m;
int true_val = 0x44000;
int false_val = 0x00888;
Node* cond_node = m.Int32Constant(0);
Node* true_node = m.Int32Constant(true_val);
Node* false_node = m.Int32Constant(false_val);
// x = false_val; while(false) { x = true_val; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel body, header, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, true_node);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(cond_node, &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(phi);
CHECK_EQ(false_val, m.Call());
}
TEST(RunLoopPhiParam) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&blocka);
m.Bind(&blocka);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi =
m.Phi(MachineRepresentation::kWord32, m.Parameter(1), m.Parameter(2));
Node* cond =
m.Phi(MachineRepresentation::kWord32, m.Parameter(0), m.Int32Constant(0));
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(cond, &blockb, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&blockb);
m.Goto(&blocka);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(phi);
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
int32_t c1 = 0xA81903B4;
int32_t c2 = 0x5A1207DA;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int result = m.Call(0, c1, c2);
CHECK_EQ(c1, result);
result = m.Call(1, c1, c2);
CHECK_EQ(c2, result);
}
TEST(RunLoopPhiInduction) {
RawMachineAssemblerTester<int32_t> m;
int false_val = 0x10777;
// x = false_val; while(false) { x++; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* false_node = m.Int32Constant(false_val);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, false_node);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(m.Int32Constant(0), &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
Node* add = m.Int32Add(phi, m.Int32Constant(1));
phi->ReplaceInput(1, add);
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(phi);
CHECK_EQ(false_val, m.Call());
}
TEST(RunLoopIncrement) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
// x = 0; while(x ^ param) { x++; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* zero = m.Int32Constant(0);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(m.WordXor(phi, bt.param0), &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(phi);
CHECK_EQ(11, bt.call(11, 0));
CHECK_EQ(110, bt.call(110, 0));
CHECK_EQ(176, bt.call(176, 0));
}
TEST(RunLoopIncrement2) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
// x = 0; while(x < param) { x++; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* zero = m.Int32Constant(0);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(m.Int32LessThan(phi, bt.param0), &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(phi);
CHECK_EQ(11, bt.call(11, 0));
CHECK_EQ(110, bt.call(110, 0));
CHECK_EQ(176, bt.call(176, 0));
CHECK_EQ(0, bt.call(-200, 0));
}
TEST(RunLoopIncrement3) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
// x = 0; while(x < param) { x++; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* zero = m.Int32Constant(0);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(m.Uint32LessThan(phi, bt.param0), &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(phi);
CHECK_EQ(11, bt.call(11, 0));
CHECK_EQ(110, bt.call(110, 0));
CHECK_EQ(176, bt.call(176, 0));
CHECK_EQ(200, bt.call(200, 0));
}
TEST(RunLoopDecrement) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
// x = param; while(x) { x--; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi =
m.Phi(MachineRepresentation::kWord32, bt.param0, m.Int32Constant(0));
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(phi, &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
phi->ReplaceInput(1, m.Int32Sub(phi, m.Int32Constant(1)));
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(phi);
CHECK_EQ(0, bt.call(11, 0));
CHECK_EQ(0, bt.call(110, 0));
CHECK_EQ(0, bt.call(197, 0));
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunLoopIncrementFloat32) {
RawMachineAssemblerTester<int32_t> m;
// x = -3.0f; while(x < 10f) { x = x + 0.5f; } return (int) (double) x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
Node* minus_3 = m.Float32Constant(-3.0f);
Node* ten = m.Float32Constant(10.0f);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kFloat32, minus_3, ten);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(m.Float32LessThan(phi, ten), &body, &end);
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
m.Bind(&body);
phi->ReplaceInput(1, m.Float32Add(phi, m.Float32Constant(0.5f)));
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
m.Return(m.ChangeFloat64ToInt32(m.ChangeFloat32ToFloat64(phi)));
CHECK_EQ(10, m.Call());
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunLoopIncrementFloat64) {
RawMachineAssemblerTester<int32_t> m;
// x = -3.0; while(x < 10) { x = x + 0.5; } return (int) x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* minus_3 = m.Float64Constant(-3.0);
Node* ten = m.Float64Constant(10.0);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kFloat64, minus_3, ten);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Branch(m.Float64LessThan(phi, ten), &body, &end);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&body);
phi->ReplaceInput(1, m.Float64Add(phi, m.Float64Constant(0.5)));
m.Goto(&header);
Make RawMachineAssemblerTest emitting CFG always have a dummy End block Frame Elider requires a sane CFG which should have such dummy end block. BUG= Review URL: https://codereview.chromium.org/1166293004 Cr-Commit-Position: refs/heads/master@{#28911}
2015-06-10 17:37:31 +00:00
m.Bind(&end);
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
m.Return(m.ChangeFloat64ToInt32(phi));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(10, m.Call());
}
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
TEST(RunSwitch1) {
RawMachineAssemblerTester<int32_t> m;
int constant = 11223344;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel block0, block1, def, end;
RawMachineLabel* case_labels[] = {&block0, &block1};
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
int32_t case_values[] = {0, 1};
m.Switch(m.Int32Constant(0), &def, case_values, case_labels,
arraysize(case_labels));
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
m.Bind(&block0);
m.Goto(&end);
m.Bind(&block1);
m.Goto(&end);
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
m.Bind(&def);
m.Goto(&end);
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
m.Bind(&end);
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
TEST(RunSwitch2) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, blockc;
RawMachineLabel* case_labels[] = {&blocka, &blockb};
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
int32_t case_values[] = {std::numeric_limits<int32_t>::min(),
std::numeric_limits<int32_t>::max()};
m.Switch(m.Parameter(0), &blockc, case_values, case_labels,
arraysize(case_labels));
m.Bind(&blocka);
m.Return(m.Int32Constant(-1));
m.Bind(&blockb);
m.Return(m.Int32Constant(1));
m.Bind(&blockc);
m.Return(m.Int32Constant(0));
CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::max()));
CHECK_EQ(-1, m.Call(std::numeric_limits<int32_t>::min()));
for (int i = -100; i < 100; i += 25) {
CHECK_EQ(0, m.Call(i));
}
}
TEST(RunSwitch3) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, blockc;
RawMachineLabel* case_labels[] = {&blocka, &blockb};
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
int32_t case_values[] = {std::numeric_limits<int32_t>::min() + 0,
std::numeric_limits<int32_t>::min() + 1};
m.Switch(m.Parameter(0), &blockc, case_values, case_labels,
arraysize(case_labels));
m.Bind(&blocka);
m.Return(m.Int32Constant(0));
m.Bind(&blockb);
m.Return(m.Int32Constant(1));
m.Bind(&blockc);
m.Return(m.Int32Constant(2));
CHECK_EQ(0, m.Call(std::numeric_limits<int32_t>::min() + 0));
CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::min() + 1));
for (int i = -100; i < 100; i += 25) {
CHECK_EQ(2, m.Call(i));
}
}
TEST(RunSwitch4) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
const size_t kNumCases = 512;
const size_t kNumValues = kNumCases + 1;
int32_t values[kNumValues];
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
m.main_isolate()->random_number_generator()->NextBytes(values,
sizeof(values));
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel end, def;
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
int32_t case_values[kNumCases];
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel* case_labels[kNumCases];
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
Node* results[kNumValues];
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
for (size_t i = 0; i < kNumCases; ++i) {
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
case_values[i] = static_cast<int32_t>(i);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
case_labels[i] =
new (m.main_zone()->New(sizeof(RawMachineLabel))) RawMachineLabel;
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
}
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
m.Switch(m.Parameter(0), &def, case_values, case_labels,
arraysize(case_labels));
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
for (size_t i = 0; i < kNumCases; ++i) {
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
m.Bind(case_labels[i]);
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
results[i] = m.Int32Constant(values[i]);
m.Goto(&end);
}
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
m.Bind(&def);
results[kNumCases] = m.Int32Constant(values[kNumCases]);
m.Goto(&end);
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
m.Bind(&end);
const int num_results = static_cast<int>(arraysize(results));
Node* phi =
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.AddNode(m.common()->Phi(MachineRepresentation::kWord32, num_results),
num_results, results);
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
m.Return(phi);
[turbofan] Optimize certain chains of Branch into a Switch. This adds a new ControlFlowOptimizer that - for now - recognizes chains of Branches generated by the SwitchBuilder for a subset of javascript switches into Switch nodes. Those Switch nodes are then lowered to either table or lookup switches. Also rename Case to IfValue (and introduce IfDefault) for consistency. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/931623002 Cr-Commit-Position: refs/heads/master@{#26691}
2015-02-17 13:29:31 +00:00
for (size_t i = 0; i < kNumValues; ++i) {
[turbofan] Initial support for Switch. Adds Switch and Case operators to TurboFan and handles them appropriately in instruction selection and code generation. BUG=v8:3872 LOG=n Review URL: https://codereview.chromium.org/892513003 Cr-Commit-Position: refs/heads/master@{#26515}
2015-02-09 08:56:01 +00:00
CHECK_EQ(values[i], m.Call(static_cast<int>(i)));
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunInt32AddP) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32Add(bt.param0, bt.param1));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected = static_cast<int32_t>(static_cast<uint32_t>(i) +
static_cast<uint32_t>(j));
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
TEST(RunInt32AddAndWord32EqualP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
m.Return(m.Int32Add(m.Parameter(0),
m.Word32Equal(m.Parameter(1), m.Parameter(2))));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<int32_t>(bit_cast<uint32_t>(i) + (j == k));
CHECK_EQ(expected, m.Call(i, j, k));
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
m.Return(m.Int32Add(m.Word32Equal(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<int32_t>((i == j) + bit_cast<uint32_t>(k));
CHECK_EQ(expected, m.Call(i, j, k));
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
}
}
}
TEST(RunInt32AddAndWord32EqualImm) {
{
FOR_INT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Add(m.Int32Constant(i),
m.Word32Equal(m.Parameter(0), m.Parameter(1))));
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
bit_cast<int32_t>(bit_cast<uint32_t>(i) + (j == k));
CHECK_EQ(expected, m.Call(j, k));
}
}
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
{
FOR_INT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Add(m.Word32Equal(m.Int32Constant(i), m.Parameter(0)),
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
m.Parameter(1)));
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<int32_t>((i == j) + bit_cast<uint32_t>(k));
CHECK_EQ(expected, m.Call(j, k));
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
}
}
}
TEST(RunInt32AddAndWord32NotEqualP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
m.Return(m.Int32Add(m.Parameter(0),
m.Word32NotEqual(m.Parameter(1), m.Parameter(2))));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<int32_t>(bit_cast<uint32_t>(i) + (j != k));
CHECK_EQ(expected, m.Call(i, j, k));
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
m.Return(m.Int32Add(m.Word32NotEqual(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<int32_t>((i != j) + bit_cast<uint32_t>(k));
CHECK_EQ(expected, m.Call(i, j, k));
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
}
}
}
TEST(RunInt32AddAndWord32NotEqualImm) {
{
FOR_INT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Add(m.Int32Constant(i),
m.Word32NotEqual(m.Parameter(0), m.Parameter(1))));
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
bit_cast<int32_t>(bit_cast<uint32_t>(i) + (j != k));
CHECK_EQ(expected, m.Call(j, k));
}
}
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
{
FOR_INT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Add(m.Word32NotEqual(m.Int32Constant(i), m.Parameter(0)),
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
m.Parameter(1)));
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
int32_t const expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<int32_t>((i != j) + bit_cast<uint32_t>(k));
CHECK_EQ(expected, m.Call(j, k));
[turbofan] Improve code generation for inline comparisons with zero. TEST=cctest,unittests R=dcarney@chromium.org Review URL: https://codereview.chromium.org/669133004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24832 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-23 10:22:06 +00:00
}
}
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunInt32AddAndWord32SarP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Add(m.Parameter(0),
m.Word32Sar(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i + (j >> shift);
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Add(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_INT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i >> shift) + k;
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunInt32AddAndWord32ShlP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Add(m.Parameter(0),
m.Word32Shl(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
FOR_UINT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i + (j << shift);
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Add(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i << shift) + k;
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunInt32AddAndWord32ShrP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Add(m.Parameter(0),
m.Word32Shr(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i + (j >> shift);
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Add(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i >> shift) + k;
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunInt32AddInBranch) {
static const int32_t constant = 987654321;
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i + j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i + j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i + j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i + j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Word32Equal(m.Int32Add(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Parameter(2))),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i + right) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunInt32AddInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i + j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i + j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(i), m.Parameter(0)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = (i + j) == 0;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(i)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = (j + i) == 0;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(
m.Int32Add(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1), m.Parameter(2))),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i + right) == 0;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunInt32SubP) {
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i - j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
TEST(RunInt32SubImm) {
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Sub(m.Int32Constant(i), m.Parameter(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = i - j;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(i)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = j - i;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
[x64] Load int32 constants with movl instead of movq to avoid sign extension. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1867293002 Cr-Commit-Position: refs/heads/master@{#35352}
2016-04-08 11:44:46 +00:00
TEST(RunInt32SubImm2) {
BufferedRawMachineAssemblerTester<int32_t> r;
r.Return(r.Int32Sub(r.Int32Constant(-1), r.Int32Constant(0)));
CHECK_EQ(-1, r.Call());
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunInt32SubAndWord32SarP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(m.Parameter(0),
m.Word32Sar(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i - (j >> shift);
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_INT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i >> shift) - k;
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunInt32SubAndWord32ShlP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(m.Parameter(0),
m.Word32Shl(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
FOR_UINT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i - (j << shift);
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
[ubsan] Avoid signed left shifts The workaround is simple: cast to unsigned before shifting. Bug: v8:3770 Change-Id: I5f0f7af697ec5db0ab1df3d061008940c83c5c56 Reviewed-on: https://chromium-review.googlesource.com/c/1436215 Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Deepti Gandluri <gdeepti@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#59140}
2019-01-25 00:33:28 +00:00
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i << shift) - k;
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunInt32SubAndWord32ShrP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(m.Parameter(0),
m.Word32Shr(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i - (j >> shift);
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
// Use uint32_t because signed overflow is UB in C.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i >> shift) - k;
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunInt32SubInBranch) {
static const int constant = 987654321;
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i - j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i - j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i - j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i - j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Word32Equal(m.Int32Sub(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Parameter(2))),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i - right) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunInt32SubInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i - j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i - j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(i), m.Parameter(0)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = (i - j) == 0;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(i)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = (j - i) == 0;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(
m.Int32Sub(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1), m.Parameter(2))),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i - right) == 0;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunInt32MulP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32Mul(bt.param0, bt.param1));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected = base::MulWithWraparound(i, j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(m.Int32Mul(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i * j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
TEST(RunInt32MulHighP) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32MulHigh(bt.param0, bt.param1));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
int32_t expected = static_cast<int32_t>(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
(static_cast<int64_t>(i) * static_cast<int64_t>(j)) >> 32);
CHECK_EQ(expected, bt.call(i, j));
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunInt32MulImm) {
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Mul(m.Int32Constant(i), m.Parameter(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = i * j;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(i)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = j * i;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunInt32MulAndInt32AddP) {
[turbofan] intel lea add multiply matchers R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/614013002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24357 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:47:14 +00:00
{
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t p0 = i;
int32_t p1 = j;
m.Return(m.Int32Add(m.Int32Constant(p0),
m.Int32Mul(m.Parameter(0), m.Int32Constant(p1))));
FOR_INT32_INPUTS(k) {
int32_t p2 = k;
int expected = base::AddWithWraparound(p0, base::MulWithWraparound(p1, p2));
CHECK_EQ(expected, m.Call(p2));
}
[turbofan] intel lea add multiply matchers R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/614013002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24357 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:47:14 +00:00
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(
m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t p0 = i;
int32_t p1 = j;
int32_t p2 = k;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
base::AddWithWraparound(p0, base::MulWithWraparound(p1, p2));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, m.Call(p0, p1, p2));
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(
m.Int32Add(m.Int32Mul(m.Parameter(0), m.Parameter(1)), m.Parameter(2)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t p0 = i;
int32_t p1 = j;
int32_t p2 = k;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
base::AddWithWraparound(base::MulWithWraparound(p0, p1), p2);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, m.Call(p0, p1, p2));
}
}
}
}
{
FOR_INT32_INPUTS(i) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int32Add(m.Int32Constant(i), m.Int32Mul(bt.param0, bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t p0 = j;
int32_t p1 = k;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
base::AddWithWraparound(i, base::MulWithWraparound(p0, p1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
}
TEST(RunInt32MulAndInt32SubP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(
m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
FOR_INT32_INPUTS(i) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t p0 = i;
int32_t p1 = j;
int32_t p2 = k;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
base::SubWithWraparound(p0, base::MulWithWraparound(p1, p2));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, m.Call(p0, p1, p2));
}
}
}
}
{
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
FOR_INT32_INPUTS(i) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int32Sub(m.Int32Constant(i), m.Int32Mul(bt.param0, bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_INT32_INPUTS(j) {
FOR_INT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t p0 = j;
int32_t p1 = k;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
base::SubWithWraparound(i, base::MulWithWraparound(p0, p1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
}
[turbofan] Also optimize unsigned division by constant. TEST=cctest,mjsunit,unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/697663003 Cr-Commit-Position: refs/heads/master@{#25061} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25061 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-11-03 10:04:37 +00:00
TEST(RunUint32MulHighP) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Uint32MulHigh(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
int32_t expected = bit_cast<int32_t>(static_cast<uint32_t>(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
(static_cast<uint64_t>(i) * static_cast<uint64_t>(j)) >> 32));
CHECK_EQ(expected, bt.call(bit_cast<int32_t>(i), bit_cast<int32_t>(j)));
[turbofan] Also optimize unsigned division by constant. TEST=cctest,mjsunit,unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/697663003 Cr-Commit-Position: refs/heads/master@{#25061} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25061 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-11-03 10:04:37 +00:00
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunInt32DivP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32Div(bt.param0, bt.param1));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int p0 = i;
int p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
int expected = static_cast<int32_t>(p0 / p1);
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32Add(bt.param0, m.Int32Div(bt.param0, bt.param1)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int p0 = i;
int p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
static_cast<int32_t>(base::AddWithWraparound(p0, (p0 / p1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
}
Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/620773003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24356 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:39:11 +00:00
TEST(RunUint32DivP) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/620773003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24356 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:39:11 +00:00
bt.AddReturn(m.Uint32Div(bt.param0, bt.param1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t p0 = i;
uint32_t p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0) {
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
int32_t expected = bit_cast<int32_t>(p0 / p1);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/620773003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24356 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:39:11 +00:00
bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Div(bt.param0, bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t p0 = i;
uint32_t p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0) {
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
int32_t expected = bit_cast<int32_t>(p0 + (p0 / p1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
}
TEST(RunInt32ModP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32Mod(bt.param0, bt.param1));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int p0 = i;
int p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
int expected = static_cast<int32_t>(p0 % p1);
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Int32Add(bt.param0, m.Int32Mod(bt.param0, bt.param1)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int p0 = i;
int p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int expected =
static_cast<int32_t>(base::AddWithWraparound(p0, (p0 % p1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
}
Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/620773003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24356 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:39:11 +00:00
TEST(RunUint32ModP) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Uint32BinopTester bt(&m);
Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/620773003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24356 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:39:11 +00:00
bt.AddReturn(m.Uint32Mod(bt.param0, bt.param1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t p0 = i;
uint32_t p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0) {
uint32_t expected = static_cast<uint32_t>(p0 % p1);
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Uint32BinopTester bt(&m);
Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/620773003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24356 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-01 10:39:11 +00:00
bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Mod(bt.param0, bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t p0 = i;
uint32_t p1 = j;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
if (p1 != 0) {
uint32_t expected = static_cast<uint32_t>(p0 + (p0 % p1));
CHECK_EQ(expected, bt.call(p0, p1));
}
}
}
}
}
TEST(RunWord32AndP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Word32And(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i & j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
bt.AddReturn(m.Word32And(bt.param0, m.Word32BitwiseNot(bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i & ~(j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
bt.AddReturn(m.Word32And(m.Word32BitwiseNot(bt.param0), bt.param1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ~(i)&j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32AndAndWord32ShlP) {
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Word32Shl(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1F))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i << (j & 0x1F);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Word32Shl(bt.param0, m.Word32And(m.Int32Constant(0x1F), bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i << (0x1F & j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32AndAndWord32ShrP) {
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Word32Shr(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1F))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i >> (j & 0x1F);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Word32Shr(bt.param0, m.Word32And(m.Int32Constant(0x1F), bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i >> (0x1F & j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32AndAndWord32SarP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Word32Sar(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1F))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_INT32_INPUTS(i) {
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i >> (j & 0x1F);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Word32Sar(bt.param0, m.Word32And(m.Int32Constant(0x1F), bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_INT32_INPUTS(i) {
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i >> (0x1F & j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32AndImm) {
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32And(m.Int32Constant(i), m.Parameter(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = i & j;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
m.Return(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Word32And(m.Int32Constant(i), m.Word32BitwiseNot(m.Parameter(0))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i & ~(j);
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32AndInBranch) {
static const int constant = 987654321;
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i & j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i & j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32Equal(m.Word32And(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i & j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32NotEqual(m.Word32And(m.Int32Constant(i), m.Parameter(0)),
m.Int32Constant(0)),
&blocka, &blockb);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i & j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Word32Equal(m.Word32And(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Parameter(2))),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i & right) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunWord32AndInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i & j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i & j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(i), m.Parameter(0)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = (i & j) == 0;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(i)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (j & i) == 0;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32OrP) {
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(m.Word32Or(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i | j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
bt.AddReturn(m.Word32Or(bt.param0, m.Word32BitwiseNot(bt.param1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i | ~(j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
bt.AddReturn(m.Word32Or(m.Word32BitwiseNot(bt.param0), bt.param1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = ~(i) | j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32OrImm) {
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Or(m.Int32Constant(i), m.Parameter(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = i | j;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
m.Return(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Word32Or(m.Int32Constant(i), m.Word32BitwiseNot(m.Parameter(0))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i | ~(j);
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32OrInBranch) {
static const int constant = 987654321;
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i | j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32NotEqual(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i | j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32Equal(m.Word32Or(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i | j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32NotEqual(m.Word32Or(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i | j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Word32Equal(m.Word32Or(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Parameter(2))),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i | right) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunWord32OrInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i | j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
Int32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Word32Or(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i | j) == 0;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(i), m.Parameter(0)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = (i | j) == 0;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(i)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (j | i) == 0;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32XorP) {
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Word32Xor(m.Int32Constant(i), m.Parameter(0)));
FOR_UINT32_INPUTS(j) {
uint32_t expected = i ^ j;
CHECK_EQ(expected, m.Call(j));
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(m.Word32Xor(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i ^ j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
bt.AddReturn(m.Word32Xor(bt.param0, m.Word32BitwiseNot(bt.param1)));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i ^ ~(j);
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
bt.AddReturn(m.Word32Xor(m.Word32BitwiseNot(bt.param0), bt.param1));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ~(i) ^ j;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
m.Return(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Word32Xor(m.Int32Constant(i), m.Word32BitwiseNot(m.Parameter(0))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i ^ ~(j);
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
TEST(RunWord32XorInBranch) {
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
static const uint32_t constant = 987654321;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i ^ j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(
m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
bt.AddReturn(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i ^ j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, bt.call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(i), m.Parameter(0)),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i ^ j) == 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
FOR_UINT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Branch(m.Word32NotEqual(m.Word32Xor(m.Int32Constant(i), m.Parameter(0)),
m.Int32Constant(0)),
&blocka, &blockb);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = (i ^ j) != 0 ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<void> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* shops[] = {m.machine()->Word32Sar(),
m.machine()->Word32Shl(),
m.machine()->Word32Shr()};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t n = 0; n < arraysize(shops); n++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Word32Equal(m.Word32Xor(m.Parameter(0),
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(shops[n], m.Parameter(1),
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Parameter(2))),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t right;
switch (shops[n]->opcode()) {
default:
UNREACHABLE();
case IrOpcode::kWord32Sar:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = j >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shl:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) << shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case IrOpcode::kWord32Shr:
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
right = static_cast<uint32_t>(j) >> shift;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i ^ right) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
}
TEST(RunWord32ShlP) {
{
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = j << shift;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(m.Word32Shl(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i << shift;
CHECK_EQ(expected, bt.call(i, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
TEST(RunWord32ShlInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Uint32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Word32Shl(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i << shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Uint32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Word32Shl(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i << shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Int32Constant(0),
m.Word32Shl(m.Parameter(0), m.Int32Constant(shift))));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i << shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i << shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunWord32ShrP) {
{
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = j >> shift;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bt.AddReturn(m.Word32Shr(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = i >> shift;
CHECK_EQ(expected, bt.call(i, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
CHECK_EQ(0x00010000u, bt.call(0x80000000, 15));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Reland "[turbofan][x64] Reduce compare-zero followed by flags-setting binop" On IA architecture, arithmetic and shifting operations set the flags according to the computation result. subl rsi,0x1 REX.W movq rbx,[rbx+0x17] cmpl rsi, 0 <-- TO BE REDUCED jnz 0x3f54d2dcef0 ==> REX.W movq rbx,[rbx+0x17] subl rsi,0x1 jnz 0x3f54d2dcef0 & orl rdx,rbx cmpl rdx,0x0 <-- TO BE REDUCED jnz 0x3f54d22b0f5 ==> orl rdx,rbx jnz 0x3f54d22b0f5 Bug: chromium:842497, chromium:842501 Change-Id: I4e2c40861b76ac3f508b01ee27249e85eab3222f Reviewed-on: https://chromium-review.googlesource.com/1057351 Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Commit-Queue: Kanghua Yu <kanghua.yu@intel.com> Cr-Commit-Position: refs/heads/master@{#53171}
2018-05-14 16:28:37 +00:00
TEST(RunWordShiftInBranch) {
static const uint32_t constant = 987654321;
FOR_UINT32_SHIFTS(shift) {
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
RawMachineLabel blocka, blockb;
m.Branch(m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = ((i << shift) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i));
Reland "[turbofan][x64] Reduce compare-zero followed by flags-setting binop" On IA architecture, arithmetic and shifting operations set the flags according to the computation result. subl rsi,0x1 REX.W movq rbx,[rbx+0x17] cmpl rsi, 0 <-- TO BE REDUCED jnz 0x3f54d2dcef0 ==> REX.W movq rbx,[rbx+0x17] subl rsi,0x1 jnz 0x3f54d2dcef0 & orl rdx,rbx cmpl rdx,0x0 <-- TO BE REDUCED jnz 0x3f54d22b0f5 ==> orl rdx,rbx jnz 0x3f54d22b0f5 Bug: chromium:842497, chromium:842501 Change-Id: I4e2c40861b76ac3f508b01ee27249e85eab3222f Reviewed-on: https://chromium-review.googlesource.com/1057351 Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Commit-Queue: Kanghua Yu <kanghua.yu@intel.com> Cr-Commit-Position: refs/heads/master@{#53171}
2018-05-14 16:28:37 +00:00
}
}
FOR_UINT32_SHIFTS(shift) {
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
RawMachineLabel blocka, blockb;
m.Branch(m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = ((i >> shift) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i));
Reland "[turbofan][x64] Reduce compare-zero followed by flags-setting binop" On IA architecture, arithmetic and shifting operations set the flags according to the computation result. subl rsi,0x1 REX.W movq rbx,[rbx+0x17] cmpl rsi, 0 <-- TO BE REDUCED jnz 0x3f54d2dcef0 ==> REX.W movq rbx,[rbx+0x17] subl rsi,0x1 jnz 0x3f54d2dcef0 & orl rdx,rbx cmpl rdx,0x0 <-- TO BE REDUCED jnz 0x3f54d22b0f5 ==> orl rdx,rbx jnz 0x3f54d22b0f5 Bug: chromium:842497, chromium:842501 Change-Id: I4e2c40861b76ac3f508b01ee27249e85eab3222f Reviewed-on: https://chromium-review.googlesource.com/1057351 Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Commit-Queue: Kanghua Yu <kanghua.yu@intel.com> Cr-Commit-Position: refs/heads/master@{#53171}
2018-05-14 16:28:37 +00:00
}
}
FOR_UINT32_SHIFTS(shift) {
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
RawMachineLabel blocka, blockb;
m.Branch(m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)),
&blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(constant));
m.Bind(&blockb);
m.Return(m.Int32Constant(0 - constant));
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i >> shift) == 0) ? constant : 0 - constant;
CHECK_EQ(expected, m.Call(i));
Reland "[turbofan][x64] Reduce compare-zero followed by flags-setting binop" On IA architecture, arithmetic and shifting operations set the flags according to the computation result. subl rsi,0x1 REX.W movq rbx,[rbx+0x17] cmpl rsi, 0 <-- TO BE REDUCED jnz 0x3f54d2dcef0 ==> REX.W movq rbx,[rbx+0x17] subl rsi,0x1 jnz 0x3f54d2dcef0 & orl rdx,rbx cmpl rdx,0x0 <-- TO BE REDUCED jnz 0x3f54d22b0f5 ==> orl rdx,rbx jnz 0x3f54d22b0f5 Bug: chromium:842497, chromium:842501 Change-Id: I4e2c40861b76ac3f508b01ee27249e85eab3222f Reviewed-on: https://chromium-review.googlesource.com/1057351 Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Commit-Queue: Kanghua Yu <kanghua.yu@intel.com> Cr-Commit-Position: refs/heads/master@{#53171}
2018-05-14 16:28:37 +00:00
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
TEST(RunWord32ShrInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Uint32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Word32Shr(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Uint32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Word32Shr(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Int32Constant(0),
m.Word32Shr(m.Parameter(0), m.Int32Constant(shift))));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunWord32SarP) {
{
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_INT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)));
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = j >> shift;
CHECK_EQ(expected, m.Call(j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(m.Word32Sar(bt.param0, bt.param1));
FOR_INT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_INT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = i >> shift;
CHECK_EQ(expected, bt.call(i, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
CHECK_EQ(bit_cast<int32_t>(0xFFFF0000), bt.call(0x80000000, 15));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
TEST(RunWord32SarInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Word32Sar(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_INT32_INPUTS(i) {
FOR_INT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Word32Sar(bt.param0, bt.param1)));
FOR_INT32_INPUTS(i) {
FOR_INT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_INT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Int32Constant(0),
m.Word32Sar(m.Parameter(0), m.Int32Constant(shift))));
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_INT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)));
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = 0 == (i >> shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
}
[turbofan] Introduce WordRor machine operator. Move recognition of rotate-right operations to the MachineOperatorReducer, so we don't need to repeat that in the InstructionSelector for every backend. TEST=base-unittests,compiler-unittests,cctests R=jarin@chromium.org Review URL: https://codereview.chromium.org/469213002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23121 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:07:58 +00:00
TEST(RunWord32RorP) {
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
[turbofan] Introduce WordRor machine operator. Move recognition of rotate-right operations to the MachineOperatorReducer, so we don't need to repeat that in the InstructionSelector for every backend. TEST=base-unittests,compiler-unittests,cctests R=jarin@chromium.org Review URL: https://codereview.chromium.org/469213002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23121 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:07:58 +00:00
m.Return(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)));
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = base::bits::RotateRight32(j, shift);
CHECK_EQ(expected, m.Call(j));
[turbofan] Introduce WordRor machine operator. Move recognition of rotate-right operations to the MachineOperatorReducer, so we don't need to repeat that in the InstructionSelector for every backend. TEST=base-unittests,compiler-unittests,cctests R=jarin@chromium.org Review URL: https://codereview.chromium.org/469213002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23121 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:07:58 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
Uint32BinopTester bt(&m);
[turbofan] Introduce WordRor machine operator. Move recognition of rotate-right operations to the MachineOperatorReducer, so we don't need to repeat that in the InstructionSelector for every backend. TEST=base-unittests,compiler-unittests,cctests R=jarin@chromium.org Review URL: https://codereview.chromium.org/469213002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23121 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:07:58 +00:00
bt.AddReturn(m.Word32Ror(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = base::bits::RotateRight32(i, shift);
CHECK_EQ(expected, bt.call(i, shift));
[turbofan] Introduce WordRor machine operator. Move recognition of rotate-right operations to the MachineOperatorReducer, so we don't need to repeat that in the InstructionSelector for every backend. TEST=base-unittests,compiler-unittests,cctests R=jarin@chromium.org Review URL: https://codereview.chromium.org/469213002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23121 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:07:58 +00:00
}
}
}
}
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
TEST(RunWord32RorInComparison) {
{
RawMachineAssemblerTester<int32_t> m;
Uint32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Word32Ror(bt.param0, bt.param1), m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == base::bits::RotateRight32(i, shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
RawMachineAssemblerTester<int32_t> m;
Uint32BinopTester bt(&m);
bt.AddReturn(
m.Word32Equal(m.Int32Constant(0), m.Word32Ror(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == base::bits::RotateRight32(i, shift);
CHECK_EQ(expected, bt.call(i, shift));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Int32Constant(0),
m.Word32Ror(m.Parameter(0), m.Int32Constant(shift))));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == base::bits::RotateRight32(i, shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
{
FOR_UINT32_SHIFTS(shift) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
m.Return(
m.Word32Equal(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)),
m.Int32Constant(0)));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = 0 == base::bits::RotateRight32(i, shift);
CHECK_EQ(expected, m.Call(i));
[arm] Recognize comparisons of shifts with zero. For example, recognize 0 == r1 << r2 and generate a single MOVS rt, r1, lsl r2 instruction. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/478233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23148 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-18 11:10:01 +00:00
}
}
}
}
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
TEST(RunWord32BitwiseNotP) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[CSA] Replace Word32Not with Word32BitwiseNot This should make the uses of binary vs. bitwise not very clear: - Word32BinaryNot for logical negation - Word32BitwiseNot for bitwise negation Change-Id: I3345913111da0dbdae6fdf285f090b67eb3f3afc Reviewed-on: https://chromium-review.googlesource.com/1169205 Commit-Queue: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#55091}
2018-08-13 13:36:15 +00:00
m.Return(m.Word32BitwiseNot(m.Parameter(0)));
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected = ~(i);
CHECK_EQ(expected, m.Call(i));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
TEST(RunInt32NegP) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Neg(m.Parameter(0)));
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected = base::NegateWithWraparound(i);
CHECK_EQ(expected, m.Call(i));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
TEST(RunWord32EqualAndWord32SarP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Int32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(m.Parameter(0),
m.Word32Sar(m.Parameter(1), m.Parameter(2))));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i == (j >> shift));
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Int32(), MachineType::Uint32(), MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_INT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_INT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i >> shift) == k);
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunWord32EqualAndWord32ShlP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(m.Parameter(0),
m.Word32Shl(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i == (j << shift));
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i << shift) == k);
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunWord32EqualAndWord32ShrP) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(m.Parameter(0),
m.Word32Shr(m.Parameter(1), m.Parameter(2))));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = (i == (j >> shift));
CHECK_EQ(expected, m.Call(i, j, shift));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
FOR_UINT32_INPUTS(i) {
Add FOR_INT32_SHIFTS to value-helper.h R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/470533002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23100 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-13 10:30:00 +00:00
FOR_UINT32_SHIFTS(shift) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_UINT32_INPUTS(k) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = ((i >> shift) == k);
CHECK_EQ(expected, m.Call(i, shift, k));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
}
}
TEST(RunDeadNodes) {
for (int i = 0; true; i++) {
[cleanup] Refactor CSignature helper The implementation can be greatly simplified by using variadic templates. R=mstarzinger@chromium.org Change-Id: I8dbeea3d570bf0fac83109f334c48dbe39aaa853 Reviewed-on: https://chromium-review.googlesource.com/859785 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#50611}
2018-01-16 09:26:02 +00:00
RawMachineAssemblerTester<int32_t> m_v;
RawMachineAssemblerTester<int32_t> m_i(MachineType::Int32());
RawMachineAssemblerTester<int32_t>& m = i == 5 ? m_i : m_v;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int constant = 0x55 + i;
switch (i) {
case 0:
m.Int32Constant(44);
break;
case 1:
m.StringConstant("unused");
break;
case 2:
m.NumberConstant(11.1);
break;
case 3:
m.PointerConstant(&constant);
break;
case 4:
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.LoadFromPointer(&constant, MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
break;
case 5:
m.Parameter(0);
break;
default:
return;
}
m.Return(m.Int32Constant(constant));
if (i != 5) {
CHECK_EQ(constant, m.Call());
} else {
CHECK_EQ(constant, m.Call(0));
}
}
}
TEST(RunDeadInt32Binops) {
RawMachineAssemblerTester<int32_t> m;
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
const Operator* kOps[] = {
[turbofan] Also optimize unsigned division by constant. TEST=cctest,mjsunit,unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/697663003 Cr-Commit-Position: refs/heads/master@{#25061} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25061 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-11-03 10:04:37 +00:00
m.machine()->Word32And(), m.machine()->Word32Or(),
m.machine()->Word32Xor(), m.machine()->Word32Shl(),
m.machine()->Word32Shr(), m.machine()->Word32Sar(),
m.machine()->Word32Ror(), m.machine()->Word32Equal(),
m.machine()->Int32Add(), m.machine()->Int32Sub(),
m.machine()->Int32Mul(), m.machine()->Int32MulHigh(),
m.machine()->Int32Div(), m.machine()->Uint32Div(),
m.machine()->Int32Mod(), m.machine()->Uint32Mod(),
m.machine()->Uint32MulHigh(), m.machine()->Int32LessThan(),
m.machine()->Int32LessThanOrEqual(), m.machine()->Uint32LessThan(),
m.machine()->Uint32LessThanOrEqual()};
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
for (size_t i = 0; i < arraysize(kOps); ++i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
[turbofan] Optimize division/modulus by constant. TEST=cctest,mjsunit,unittests R=dcarney@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/654833002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-14 11:57:06 +00:00
int32_t constant = static_cast<int32_t>(0x55555 + i);
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(kOps[i], m.Parameter(0), m.Parameter(1));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call(1, 1));
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat32Add) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float32Add(m.Parameter(0), m.Parameter(1)));
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(i + j, m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat32Sub) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float32Sub(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(i - j, m.Call(i, j)); }
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
}
}
[arm] [arm64] Add optional operators Float32Neg and Float64Neg. Adding optional operators for FNeg for WebAssembly, as the current implementation was significantly suboptimal for ARM. Review-Url: https://codereview.chromium.org/2011303002 Cr-Commit-Position: refs/heads/master@{#36544}
2016-05-27 11:20:32 +00:00
TEST(RunFloat32Neg) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[turbofan] Make Float32Neg and Float64Neg mandatory operators. R=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/2215403002 Cr-Commit-Position: refs/heads/master@{#38399}
2016-08-05 18:49:15 +00:00
m.Return(m.AddNode(m.machine()->Float32Neg(), m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(-0.0f - i, m.Call(i)); }
[arm] [arm64] Add optional operators Float32Neg and Float64Neg. Adding optional operators for FNeg for WebAssembly, as the current implementation was significantly suboptimal for ARM. Review-Url: https://codereview.chromium.org/2011303002 Cr-Commit-Position: refs/heads/master@{#36544}
2016-05-27 11:20:32 +00:00
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat32Mul) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float32Mul(m.Parameter(0), m.Parameter(1)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(i * j, m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat32Div) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float32Div(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(base::Divide(i, j), m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
TEST(RunFloat64Add) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Add(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(i + j, m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
TEST(RunFloat64Sub) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Sub(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(i - j, m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
[arm] [arm64] Add optional operators Float32Neg and Float64Neg. Adding optional operators for FNeg for WebAssembly, as the current implementation was significantly suboptimal for ARM. Review-Url: https://codereview.chromium.org/2011303002 Cr-Commit-Position: refs/heads/master@{#36544}
2016-05-27 11:20:32 +00:00
TEST(RunFloat64Neg) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Make Float32Neg and Float64Neg mandatory operators. R=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/2215403002 Cr-Commit-Position: refs/heads/master@{#38399}
2016-08-05 18:49:15 +00:00
m.Return(m.AddNode(m.machine()->Float64Neg(), m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(-0.0 - i, m.Call(i)); }
[arm] [arm64] Add optional operators Float32Neg and Float64Neg. Adding optional operators for FNeg for WebAssembly, as the current implementation was significantly suboptimal for ARM. Review-Url: https://codereview.chromium.org/2011303002 Cr-Commit-Position: refs/heads/master@{#36544}
2016-05-27 11:20:32 +00:00
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64Mul) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Mul(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(i * j, m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
TEST(RunFloat64Div) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Div(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(base::Divide(i, j), m.Call(i, j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
TEST(RunFloat64Mod) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Mod(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(Modulo(i, j), m.Call(i, j)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunDeadFloat32Binops) {
RawMachineAssemblerTester<int32_t> m;
const Operator* ops[] = {m.machine()->Float32Add(), m.machine()->Float32Sub(),
m.machine()->Float32Mul(), m.machine()->Float32Div(),
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
nullptr};
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
for (int i = 0; ops[i] != nullptr; i++) {
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
RawMachineAssemblerTester<int32_t> m;
int constant = 0x53355 + i;
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(ops[i], m.Float32Constant(0.1f), m.Float32Constant(1.11f));
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunDeadFloat64Binops) {
RawMachineAssemblerTester<int32_t> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
m.machine()->Float64Mul(), m.machine()->Float64Div(),
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
m.machine()->Float64Mod(), nullptr};
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
for (int i = 0; ops[i] != nullptr; i++) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
RawMachineAssemblerTester<int32_t> m;
int constant = 0x53355 + i;
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.AddNode(ops[i], m.Float64Constant(0.1), m.Float64Constant(1.11));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call());
}
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunFloat32AddP) {
RawMachineAssemblerTester<int32_t> m;
Float32BinopTester bt(&m);
bt.AddReturn(m.Float32Add(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(pl + pr, bt.call(pl, pr)); }
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunFloat64AddP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Add(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(pl + pr, bt.call(pl, pr)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
MIPS: [turbofan] Properly implement Float64/32 Min/Max instructions. TEST=cctest/test-run-machops/Float(64|32)MaxP, Float(64|32)MinP, unittests/InstructionSelectorTest.Float64Min|Max BUG=v8:4206 LOG=N Review URL: https://codereview.chromium.org/1419753008 Cr-Commit-Position: refs/heads/master@{#31806}
2015-11-04 21:02:50 +00:00
TEST(RunFloat64MaxP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Max(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(JSMax(pl, pr), bt.call(pl, pr)); }
MIPS: [turbofan] Properly implement Float64/32 Min/Max instructions. TEST=cctest/test-run-machops/Float(64|32)MaxP, Float(64|32)MinP, unittests/InstructionSelectorTest.Float64Min|Max BUG=v8:4206 LOG=N Review URL: https://codereview.chromium.org/1419753008 Cr-Commit-Position: refs/heads/master@{#31806}
2015-11-04 21:02:50 +00:00
}
}
TEST(RunFloat64MinP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Min(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(JSMin(pl, pr), bt.call(pl, pr)); }
MIPS: [turbofan] Properly implement Float64/32 Min/Max instructions. TEST=cctest/test-run-machops/Float(64|32)MaxP, Float(64|32)MinP, unittests/InstructionSelectorTest.Float64Min|Max BUG=v8:4206 LOG=N Review URL: https://codereview.chromium.org/1419753008 Cr-Commit-Position: refs/heads/master@{#31806}
2015-11-04 21:02:50 +00:00
}
}
[turbofan] Add Float32(Max|Min) machine operators. The new operators are implemented similar to the Float64(Max|Min) which already exist. The purpose of the new operators is the implementation of the F32Max and F32Min instructions in WebAssembly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review-Url: https://codereview.chromium.org/2252863003 Cr-Commit-Position: refs/heads/master@{#38784}
2016-08-22 13:50:23 +00:00
TEST(RunFloat32Max) {
RawMachineAssemblerTester<int32_t> m;
Float32BinopTester bt(&m);
bt.AddReturn(m.Float32Max(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(JSMax(pl, pr), bt.call(pl, pr)); }
[turbofan] Add Float32(Max|Min) machine operators. The new operators are implemented similar to the Float64(Max|Min) which already exist. The purpose of the new operators is the implementation of the F32Max and F32Min instructions in WebAssembly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review-Url: https://codereview.chromium.org/2252863003 Cr-Commit-Position: refs/heads/master@{#38784}
2016-08-22 13:50:23 +00:00
}
}
TEST(RunFloat32Min) {
RawMachineAssemblerTester<int32_t> m;
Float32BinopTester bt(&m);
bt.AddReturn(m.Float32Min(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(JSMin(pl, pr), bt.call(pl, pr)); }
[turbofan] Add Float32(Max|Min) machine operators. The new operators are implemented similar to the Float64(Max|Min) which already exist. The purpose of the new operators is the implementation of the F32Max and F32Min instructions in WebAssembly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review-Url: https://codereview.chromium.org/2252863003 Cr-Commit-Position: refs/heads/master@{#38784}
2016-08-22 13:50:23 +00:00
}
}
MIPS: [turbofan] Properly implement Float64/32 Min/Max instructions. TEST=cctest/test-run-machops/Float(64|32)MaxP, Float(64|32)MinP, unittests/InstructionSelectorTest.Float64Min|Max BUG=v8:4206 LOG=N Review URL: https://codereview.chromium.org/1419753008 Cr-Commit-Position: refs/heads/master@{#31806}
2015-11-04 21:02:50 +00:00
MIPS: Improve Float(32|64)(Max|Min). Port for 3396bb290701c600dd600081f04803b14f0f9084 TEST= BUG= Review-Url: https://codereview.chromium.org/2534413002 Cr-Commit-Position: refs/heads/master@{#41508}
2016-12-06 10:16:13 +00:00
TEST(RunFloat64Max) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Max(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(JSMax(pl, pr), bt.call(pl, pr)); }
MIPS: Improve Float(32|64)(Max|Min). Port for 3396bb290701c600dd600081f04803b14f0f9084 TEST= BUG= Review-Url: https://codereview.chromium.org/2534413002 Cr-Commit-Position: refs/heads/master@{#41508}
2016-12-06 10:16:13 +00:00
}
}
TEST(RunFloat64Min) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Min(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(JSMin(pl, pr), bt.call(pl, pr)); }
MIPS: Improve Float(32|64)(Max|Min). Port for 3396bb290701c600dd600081f04803b14f0f9084 TEST= BUG= Review-Url: https://codereview.chromium.org/2534413002 Cr-Commit-Position: refs/heads/master@{#41508}
2016-12-06 10:16:13 +00:00
}
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunFloat32SubP) {
RawMachineAssemblerTester<int32_t> m;
Float32BinopTester bt(&m);
bt.AddReturn(m.Float32Sub(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(pl - pr, bt.call(pl, pr)); }
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
}
}
[x64] Match -0 - x with sign bit flip. We can use xorps/xorpd on Intel CPUs to flip the sign bit. Ideally we'd use a RIP-relative 128-bit constant in the code object, as OCaml/GCC does, however that requires 128-bit alignment for code objects, which is not yet implemented. So for now we materialize the mask inline. R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1046893002 Cr-Commit-Position: refs/heads/master@{#27611}
2015-04-07 07:34:55 +00:00
TEST(RunFloat32SubImm1) {
FOR_FLOAT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float32Sub(m.Float32Constant(i), m.Parameter(0)));
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(i - j, m.Call(j)); }
[x64] Match -0 - x with sign bit flip. We can use xorps/xorpd on Intel CPUs to flip the sign bit. Ideally we'd use a RIP-relative 128-bit constant in the code object, as OCaml/GCC does, however that requires 128-bit alignment for code objects, which is not yet implemented. So for now we materialize the mask inline. R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1046893002 Cr-Commit-Position: refs/heads/master@{#27611}
2015-04-07 07:34:55 +00:00
}
}
TEST(RunFloat32SubImm2) {
FOR_FLOAT32_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float32Sub(m.Parameter(0), m.Float32Constant(i)));
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(j - i, m.Call(j)); }
[x64] Match -0 - x with sign bit flip. We can use xorps/xorpd on Intel CPUs to flip the sign bit. Ideally we'd use a RIP-relative 128-bit constant in the code object, as OCaml/GCC does, however that requires 128-bit alignment for code objects, which is not yet implemented. So for now we materialize the mask inline. R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1046893002 Cr-Commit-Position: refs/heads/master@{#27611}
2015-04-07 07:34:55 +00:00
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64SubImm1) {
FOR_FLOAT64_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float64Sub(m.Float64Constant(i), m.Parameter(0)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(i - j, m.Call(j)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64SubImm2) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_FLOAT64_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float64Sub(m.Parameter(0), m.Float64Constant(i)));
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(j - i, m.Call(j)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64SubP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
bt.AddReturn(m.Float64Sub(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
double expected = pl - pr;
CHECK_DOUBLE_EQ(expected, bt.call(pl, pr));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunFloat32MulP) {
RawMachineAssemblerTester<int32_t> m;
Float32BinopTester bt(&m);
bt.AddReturn(m.Float32Mul(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(pl * pr, bt.call(pl, pr)); }
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunFloat64MulP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Mul(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
double expected = pl * pr;
CHECK_DOUBLE_EQ(expected, bt.call(pl, pr));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
[arm64][turbofan] FP simplification FNMUL is efficient arm64 instruction, which can save 1 cycle by optimizing FNEG(FMUL x y)) to FNMUL x y and FMUL((FNEG x) y) to FNMUL x y Change-Id: If25d9de1253098b17033a9d8736ff6a1c06601f3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1572681 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Martyn Capewell <martyn.capewell@arm.com> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#61230}
2019-04-25 22:35:41 +00:00
TEST(RunFloat32MulAndFloat32Neg) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
m.Return(m.Float32Neg(m.Float32Mul(m.Parameter(0), m.Parameter(1))));
FOR_FLOAT32_INPUTS(i) {
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(-(i * j), m.Call(i, j)); }
}
}
TEST(RunFloat64MulAndFloat64Neg) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
m.Return(m.Float64Neg(m.Float64Mul(m.Parameter(0), m.Parameter(1))));
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(-(i * j), m.Call(i, j)); }
}
}
TEST(RunFloat32NegAndFloat32Mul1) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
m.Return(m.Float32Mul(m.Float32Neg(m.Parameter(0)), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ((-i * j), m.Call(i, j)); }
}
}
TEST(RunFloat64NegAndFloat64Mul1) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
m.Return(m.Float64Mul(m.Float64Neg(m.Parameter(0)), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ((-i * j), m.Call(i, j)); }
}
}
TEST(RunFloat32NegAndFloat32Mul2) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
m.Return(m.Float32Mul(m.Parameter(0), m.Float32Neg(m.Parameter(1))));
FOR_FLOAT32_INPUTS(i) {
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ((i * -j), m.Call(i, j)); }
}
}
TEST(RunFloat64NegAndFloat64Mul2) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
m.Return(m.Float64Mul(m.Parameter(0), m.Float64Neg(m.Parameter(1))));
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ((i * -j), m.Call(i, j)); }
}
}
TEST(RunFloat32NegAndFloat32Mul3) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
m.Return(
m.Float32Mul(m.Float32Neg(m.Parameter(0)), m.Float32Neg(m.Parameter(1))));
FOR_FLOAT32_INPUTS(i) {
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ((-i * -j), m.Call(i, j)); }
}
}
TEST(RunFloat64NegAndFloat64Mul3) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
m.Return(
m.Float64Mul(m.Float64Neg(m.Parameter(0)), m.Float64Neg(m.Parameter(1))));
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ((-i * -j), m.Call(i, j)); }
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64MulAndFloat64Add1) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(
MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Add(m.Float64Mul(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(k) { CHECK_DOUBLE_EQ((i * j) + k, m.Call(i, j, k)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
TEST(RunFloat64MulAndFloat64Add2) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(
MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Add(m.Parameter(0),
m.Float64Mul(m.Parameter(1), m.Parameter(2))));
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(k) { CHECK_DOUBLE_EQ(i + (j * k), m.Call(i, j, k)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64MulAndFloat64Sub1) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(
MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Sub(m.Float64Mul(m.Parameter(0), m.Parameter(1)),
m.Parameter(2)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(k) { CHECK_DOUBLE_EQ((i * j) - k, m.Call(i, j, k)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
TEST(RunFloat64MulAndFloat64Sub2) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(
MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.Float64Sub(m.Parameter(0),
m.Float64Mul(m.Parameter(1), m.Parameter(2))));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(k) { CHECK_DOUBLE_EQ(i - (j * k), m.Call(i, j, k)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
TEST(RunFloat64MulImm1) {
FOR_FLOAT64_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float64Mul(m.Float64Constant(i), m.Parameter(0)));
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(i * j, m.Call(j)); }
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
}
}
TEST(RunFloat64MulImm2) {
FOR_FLOAT64_INPUTS(i) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float64Mul(m.Parameter(0), m.Float64Constant(i)));
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(j * i, m.Call(j)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunFloat32DivP) {
RawMachineAssemblerTester<int32_t> m;
Float32BinopTester bt(&m);
bt.AddReturn(m.Float32Div(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
FOR_FLOAT32_INPUTS(pr) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_FLOAT_EQ(base::Divide(pl, pr), bt.call(pl, pr));
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
}
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunFloat64DivP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Div(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
FOR_FLOAT64_INPUTS(pr) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_DOUBLE_EQ(base::Divide(pl, pr), bt.call(pl, pr));
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
TEST(RunFloat64ModP) {
RawMachineAssemblerTester<int32_t> m;
Float64BinopTester bt(&m);
bt.AddReturn(m.Float64Mod(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(Modulo(i, j), bt.call(i, j)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
TEST(RunChangeInt32ToFloat64_A) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t magic = 0x986234;
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
BufferedRawMachineAssemblerTester<double> m;
m.Return(m.ChangeInt32ToFloat64(m.Int32Constant(magic)));
x87: fix the use of CheckFloatEq and CheckDoubleEq in test. Instead of using CheckFloatEq and CheckDoubleEq directly, I introduced a macro which first stores the expected result in a volatile variable. Here are some comments of previous CLs: The reason is same as the CL #31808 (issue 1430943002, X87: Change the test case for X87 float operations), please refer: https://codereview.chromium.org/1430943002/. Here is the key comments from CL #31808 Some new test cases use CheckFloatEq(...) and CheckDoubleEq(...) function for result check. When GCC compiling the CheckFloatEq() and CheckDoubleEq() function, those inlined functions has different behavior comparing with GCC ia32 build and x87 build. The major difference is sse float register still has single precision rounding semantic. While X87 register has no such rounding precsion semantic when directly use register value. The V8 turbofan JITTed has exactly same result in both X87 and IA32 port. So we add the following sentence to do type cast to keep the same precision for RunCallInt64ToFloat32/RunCallInt64ToFloat64. Such as: volatile double expect = static_cast<float>(*i). R=titzer@chromium.org, weiliang.lin@intel.com Review URL: https://codereview.chromium.org/1773513002 Cr-Commit-Position: refs/heads/master@{#34534}
2016-03-07 12:29:06 +00:00
CHECK_DOUBLE_EQ(static_cast<double>(magic), m.Call());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
TEST(RunChangeInt32ToFloat64_B) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Int32());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.ChangeInt32ToFloat64(m.Parameter(0)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_INT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(i), m.Call(i)); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
TEST(RunChangeUint32ToFloat64) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Uint32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.ChangeUint32ToFloat64(m.Parameter(0)));
[turbofan] IA: Uint32ToFloat64 supports mem operand. BUG= R=dcarney@chromium.org Review URL: https://codereview.chromium.org/583963002 Patch from Jing Bao <jing.bao@intel.com>. git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24318 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-30 10:24:11 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_UINT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(i), m.Call(i)); }
[turbofan] IA: Uint32ToFloat64 supports mem operand. BUG= R=dcarney@chromium.org Review URL: https://codereview.chromium.org/583963002 Patch from Jing Bao <jing.bao@intel.com>. git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24318 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-30 10:24:11 +00:00
}
[turbofan] Add the TruncateFloat32ToInt32 operator to turbofan. The new operator converts a float32 input to int32 through truncation. I provide implementations of the new operator for x64, ia32, arm, arm64, mips, mips64, and x87. @v8-ppc-ports, can you please take care of the ppc implementation? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com, weiliang.lin@intel.com Review URL: https://codereview.chromium.org/1583323004 Cr-Commit-Position: refs/heads/master@{#33346}
2016-01-16 11:40:47 +00:00
TEST(RunTruncateFloat32ToInt32) {
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Float32());
m.Return(m.TruncateFloat32ToInt32(m.Parameter(0)));
[wasm] Detect unrepresentability in the float32-to-int32 conversion correctly on arm. In the current implementation of wasm an unrepresentable input of the float32-to-int32 conversion is detected by first truncating the input, then converting the truncated input to int32 and back to float32, and then checking whether the result is the same as the truncated input. This input check does not work on arm and arm64 for an input of (INT32_MAX + 1) because on these platforms the float32-to-int32 conversion results in INT32_MAX if the input is greater than INT32_MAX. When INT32_MAX is converted back to float32, then the result is (INT32_MAX + 1) again because INT32_MAX cannot be represented precisely as float32, and rounding-to-nearest results in (INT32_MAX + 1). Since (INT32_MAX + 1) equals the truncated input value, the input appears to be representable. With the changes in this CL, the result of the float32-to-int32 conversion is incremented by 1 if the original result was INT32_MAX. Thereby the detection of unrepresenable inputs in wasm works. Note that since INT32_MAX cannot be represented precisely in float32, it can also never be a valid result of the float32-to-int32 conversion. @v8-mips-ports, can you do a similar implementation for mips? R=titzer@chromium.org, Rodolph.Perfetta@arm.com Review-Url: https://codereview.chromium.org/2105313002 Cr-Commit-Position: refs/heads/master@{#37448}
2016-06-30 14:29:36 +00:00
// The upper bound is (INT32_MAX + 1), which is the lowest float-representable
// number above INT32_MAX which cannot be represented as int32.
float upper_bound = 2147483648.0f;
// We use INT32_MIN as a lower bound because (INT32_MIN - 1) is not
// representable as float, and no number between (INT32_MIN - 1) and INT32_MIN
// is.
float lower_bound = static_cast<float>(INT32_MIN);
[turbofan] Add the TruncateFloat32ToInt32 operator to turbofan. The new operator converts a float32 input to int32 through truncation. I provide implementations of the new operator for x64, ia32, arm, arm64, mips, mips64, and x87. @v8-ppc-ports, can you please take care of the ppc implementation? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com, weiliang.lin@intel.com Review URL: https://codereview.chromium.org/1583323004 Cr-Commit-Position: refs/heads/master@{#33346}
2016-01-16 11:40:47 +00:00
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (i < upper_bound && i >= lower_bound) {
CHECK_FLOAT_EQ(static_cast<int32_t>(i), m.Call(i));
[turbofan] Add the TruncateFloat32ToInt32 operator to turbofan. The new operator converts a float32 input to int32 through truncation. I provide implementations of the new operator for x64, ia32, arm, arm64, mips, mips64, and x87. @v8-ppc-ports, can you please take care of the ppc implementation? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com, weiliang.lin@intel.com Review URL: https://codereview.chromium.org/1583323004 Cr-Commit-Position: refs/heads/master@{#33346}
2016-01-16 11:40:47 +00:00
}
}
}
[turbofan] Add TruncateFloat32ToUint32 operator to Turbofan. BUG= Review URL: https://codereview.chromium.org/1627263002 Cr-Commit-Position: refs/heads/master@{#33797}
2016-02-06 18:08:54 +00:00
TEST(RunTruncateFloat32ToUint32) {
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float32());
m.Return(m.TruncateFloat32ToUint32(m.Parameter(0)));
[wasm] Detect unrepresentability in the float32-to-int32 conversion correctly on arm. In the current implementation of wasm an unrepresentable input of the float32-to-int32 conversion is detected by first truncating the input, then converting the truncated input to int32 and back to float32, and then checking whether the result is the same as the truncated input. This input check does not work on arm and arm64 for an input of (INT32_MAX + 1) because on these platforms the float32-to-int32 conversion results in INT32_MAX if the input is greater than INT32_MAX. When INT32_MAX is converted back to float32, then the result is (INT32_MAX + 1) again because INT32_MAX cannot be represented precisely as float32, and rounding-to-nearest results in (INT32_MAX + 1). Since (INT32_MAX + 1) equals the truncated input value, the input appears to be representable. With the changes in this CL, the result of the float32-to-int32 conversion is incremented by 1 if the original result was INT32_MAX. Thereby the detection of unrepresenable inputs in wasm works. Note that since INT32_MAX cannot be represented precisely in float32, it can also never be a valid result of the float32-to-int32 conversion. @v8-mips-ports, can you do a similar implementation for mips? R=titzer@chromium.org, Rodolph.Perfetta@arm.com Review-Url: https://codereview.chromium.org/2105313002 Cr-Commit-Position: refs/heads/master@{#37448}
2016-06-30 14:29:36 +00:00
// The upper bound is (UINT32_MAX + 1), which is the lowest
// float-representable number above UINT32_MAX which cannot be represented as
// uint32.
double upper_bound = 4294967296.0f;
double lower_bound = -1.0f;
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
volatile float input = static_cast<float>(i);
[wasm] Detect unrepresentability in the float32-to-int32 conversion correctly on arm. In the current implementation of wasm an unrepresentable input of the float32-to-int32 conversion is detected by first truncating the input, then converting the truncated input to int32 and back to float32, and then checking whether the result is the same as the truncated input. This input check does not work on arm and arm64 for an input of (INT32_MAX + 1) because on these platforms the float32-to-int32 conversion results in INT32_MAX if the input is greater than INT32_MAX. When INT32_MAX is converted back to float32, then the result is (INT32_MAX + 1) again because INT32_MAX cannot be represented precisely as float32, and rounding-to-nearest results in (INT32_MAX + 1). Since (INT32_MAX + 1) equals the truncated input value, the input appears to be representable. With the changes in this CL, the result of the float32-to-int32 conversion is incremented by 1 if the original result was INT32_MAX. Thereby the detection of unrepresenable inputs in wasm works. Note that since INT32_MAX cannot be represented precisely in float32, it can also never be a valid result of the float32-to-int32 conversion. @v8-mips-ports, can you do a similar implementation for mips? R=titzer@chromium.org, Rodolph.Perfetta@arm.com Review-Url: https://codereview.chromium.org/2105313002 Cr-Commit-Position: refs/heads/master@{#37448}
2016-06-30 14:29:36 +00:00
if (input < upper_bound) {
CHECK_EQ(static_cast<uint32_t>(input), m.Call(input));
[turbofan] Add TruncateFloat32ToUint32 operator to Turbofan. BUG= Review URL: https://codereview.chromium.org/1627263002 Cr-Commit-Position: refs/heads/master@{#33797}
2016-02-06 18:08:54 +00:00
}
}
[wasm] Detect unrepresentability in the float32-to-int32 conversion correctly on arm. In the current implementation of wasm an unrepresentable input of the float32-to-int32 conversion is detected by first truncating the input, then converting the truncated input to int32 and back to float32, and then checking whether the result is the same as the truncated input. This input check does not work on arm and arm64 for an input of (INT32_MAX + 1) because on these platforms the float32-to-int32 conversion results in INT32_MAX if the input is greater than INT32_MAX. When INT32_MAX is converted back to float32, then the result is (INT32_MAX + 1) again because INT32_MAX cannot be represented precisely as float32, and rounding-to-nearest results in (INT32_MAX + 1). Since (INT32_MAX + 1) equals the truncated input value, the input appears to be representable. With the changes in this CL, the result of the float32-to-int32 conversion is incremented by 1 if the original result was INT32_MAX. Thereby the detection of unrepresenable inputs in wasm works. Note that since INT32_MAX cannot be represented precisely in float32, it can also never be a valid result of the float32-to-int32 conversion. @v8-mips-ports, can you do a similar implementation for mips? R=titzer@chromium.org, Rodolph.Perfetta@arm.com Review-Url: https://codereview.chromium.org/2105313002 Cr-Commit-Position: refs/heads/master@{#37448}
2016-06-30 14:29:36 +00:00
FOR_FLOAT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if ((j < upper_bound) && (j > lower_bound)) {
CHECK_FLOAT_EQ(static_cast<uint32_t>(j), m.Call(j));
[turbofan] Add TruncateFloat32ToUint32 operator to Turbofan. BUG= Review URL: https://codereview.chromium.org/1627263002 Cr-Commit-Position: refs/heads/master@{#33797}
2016-02-06 18:08:54 +00:00
}
}
}
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
TEST(RunChangeFloat64ToInt32_A) {
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
BufferedRawMachineAssemblerTester<int32_t> m;
double magic = 11.1;
m.Return(m.ChangeFloat64ToInt32(m.Float64Constant(magic)));
CHECK_EQ(static_cast<int32_t>(magic), m.Call());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
TEST(RunChangeFloat64ToInt32_B) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Float64());
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
m.Return(m.ChangeFloat64ToInt32(m.Parameter(0)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
// Note we don't check fractional inputs, or inputs outside the range of
// int32, because these Convert operators really should be Change operators.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_INT32_INPUTS(i) { CHECK_EQ(i, m.Call(static_cast<double>(i))); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
for (int32_t n = 1; n < 31; ++n) {
CHECK_EQ(1 << n, m.Call(static_cast<double>(1 << n)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
TF: Add ConvertFloat64ToUint32 and ConvertUint32ToFloat64 machine operators. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/431473004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22752 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 11:45:22 +00:00
for (int32_t n = 1; n < 31; ++n) {
Changed some tests to use the BufferedRawMachineAssemblerTester. The BufferedRawMachineAssemblerTester takes care of storing and loading parameters to and from memory for these test cases. By using the BufferedRawMachineAssemblerTester the test cases become more readible. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1409013004 Cr-Commit-Position: refs/heads/master@{#31718}
2015-11-02 19:19:14 +00:00
CHECK_EQ(3 << n, m.Call(static_cast<double>(3 << n)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
}
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
TEST(RunChangeFloat64ToUint32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.ChangeFloat64ToUint32(m.Parameter(0)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TF: Add ConvertFloat64ToUint32 and ConvertUint32ToFloat64 machine operators. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/431473004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22752 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 11:45:22 +00:00
{
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_UINT32_INPUTS(i) { CHECK_EQ(i, m.Call(static_cast<double>(i))); }
TF: Add ConvertFloat64ToUint32 and ConvertUint32ToFloat64 machine operators. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/431473004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22752 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 11:45:22 +00:00
}
// Check various powers of 2.
for (int32_t n = 1; n < 31; ++n) {
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
{ CHECK_EQ(1u << n, m.Call(static_cast<double>(1u << n))); }
TF: Add ConvertFloat64ToUint32 and ConvertUint32ToFloat64 machine operators. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/431473004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22752 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 11:45:22 +00:00
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
{ CHECK_EQ(3u << n, m.Call(static_cast<double>(3u << n))); }
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
TF: Add ConvertFloat64ToUint32 and ConvertUint32ToFloat64 machine operators. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/431473004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22752 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 11:45:22 +00:00
// Note we don't check fractional inputs, because these Convert operators
// really should be Change operators.
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
TEST(RunTruncateFloat64ToFloat32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float64());
[turbofan] IA: TruncateFloat64ToFloat32 supports mem operand BUG= R=dcarney@chromium.org Review URL: https://codereview.chromium.org/639283003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24541 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-13 07:12:57 +00:00
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0)));
[turbofan] IA: TruncateFloat64ToFloat32 supports mem operand BUG= R=dcarney@chromium.org Review URL: https://codereview.chromium.org/639283003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24541 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-13 07:12:57 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(DoubleToFloat32(i), m.Call(i)); }
[turbofan] IA: TruncateFloat64ToFloat32 supports mem operand BUG= R=dcarney@chromium.org Review URL: https://codereview.chromium.org/639283003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24541 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-13 07:12:57 +00:00
}
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
uint64_t ToInt64(uint32_t low, uint32_t high) {
return (static_cast<uint64_t>(high) << 32) | static_cast<uint64_t>(low);
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
}
MIPS: [wasm] Lowering of Int64Shl, Int64Shr, Int64Sar, Int64Add and Int64Sub. Implementation of turbofan operators Word32PairShl, Word32PairShr, Word32PairSar, Int32AddPair and Int32SubPair for MIPS. Port of: https://codereview.chromium.org/1765973002/ https://codereview.chromium.org/1778893004/ https://codereview.chromium.org/1778493004/ https://codereview.chromium.org/1778893005/ https://codereview.chromium.org/1842013002/ Added tests for Word32PairShr and Word32PairSar in test-run-machops.cc. BUG= Review URL: https://codereview.chromium.org/1819383002 Cr-Commit-Position: refs/heads/master@{#35307}
2016-04-06 14:43:28 +00:00
#if V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_X87
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
TEST(RunInt32PairAdd) {
BufferedRawMachineAssemblerTester<int32_t> m(
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
MachineType::Uint32());
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
uint32_t high;
uint32_t low;
Node* PairAdd = m.Int32PairAdd(m.Parameter(0), m.Parameter(1), m.Parameter(2),
m.Parameter(3));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairAdd));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairAdd));
m.Return(m.Int32Constant(74));
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32),
static_cast<uint32_t>(j & 0xFFFFFFFF),
static_cast<uint32_t>(j >> 32));
CHECK_EQ(i + j, ToInt64(low, high));
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
}
}
}
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
TEST(RunInt32PairAddUseOnlyHighWord) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
MachineType::Uint32());
m.Return(m.Projection(1, m.Int32PairAdd(m.Parameter(0), m.Parameter(1),
m.Parameter(2), m.Parameter(3))));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
[turbofan] Fix -Wsign-compare warnings. BUG=v8:5614 Review-Url: https://codereview.chromium.org/2490973002 Cr-Commit-Position: refs/heads/master@{#40879}
2016-11-10 10:02:44 +00:00
CHECK_EQ(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
static_cast<uint32_t>((i + j) >> 32),
static_cast<uint32_t>(m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32),
static_cast<uint32_t>(j & 0xFFFFFFFF),
static_cast<uint32_t>(j >> 32))));
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
}
}
}
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
void TestInt32PairAddWithSharedInput(int a, int b, int c, int d) {
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairAdd = m.Int32PairAdd(m.Parameter(a), m.Parameter(b), m.Parameter(c),
m.Parameter(d));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairAdd));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairAdd));
m.Return(m.Int32Constant(74));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i, j);
uint32_t inputs[] = {i, j};
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
CHECK_EQ(ToInt64(inputs[a], inputs[b]) + ToInt64(inputs[c], inputs[d]),
ToInt64(low, high));
}
}
}
TEST(RunInt32PairAddWithSharedInput) {
TestInt32PairAddWithSharedInput(0, 0, 0, 0);
TestInt32PairAddWithSharedInput(1, 0, 0, 0);
TestInt32PairAddWithSharedInput(0, 1, 0, 0);
TestInt32PairAddWithSharedInput(0, 0, 1, 0);
TestInt32PairAddWithSharedInput(0, 0, 0, 1);
TestInt32PairAddWithSharedInput(1, 1, 0, 0);
}
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
TEST(RunInt32PairSub) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairSub = m.Int32PairSub(m.Parameter(0), m.Parameter(1), m.Parameter(2),
m.Parameter(3));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairSub));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairSub));
m.Return(m.Int32Constant(74));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32),
static_cast<uint32_t>(j & 0xFFFFFFFF),
static_cast<uint32_t>(j >> 32));
CHECK_EQ(i - j, ToInt64(low, high));
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
}
}
}
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
TEST(RunInt32PairSubUseOnlyHighWord) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
MachineType::Uint32());
m.Return(m.Projection(1, m.Int32PairSub(m.Parameter(0), m.Parameter(1),
m.Parameter(2), m.Parameter(3))));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
[turbofan] Fix -Wsign-compare warnings. BUG=v8:5614 Review-Url: https://codereview.chromium.org/2490973002 Cr-Commit-Position: refs/heads/master@{#40879}
2016-11-10 10:02:44 +00:00
CHECK_EQ(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
static_cast<uint32_t>((i - j) >> 32),
static_cast<uint32_t>(m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32),
static_cast<uint32_t>(j & 0xFFFFFFFF),
static_cast<uint32_t>(j >> 32))));
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
}
}
}
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
void TestInt32PairSubWithSharedInput(int a, int b, int c, int d) {
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairSub = m.Int32PairSub(m.Parameter(a), m.Parameter(b), m.Parameter(c),
m.Parameter(d));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairSub));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairSub));
m.Return(m.Int32Constant(74));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i, j);
uint32_t inputs[] = {i, j};
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
CHECK_EQ(ToInt64(inputs[a], inputs[b]) - ToInt64(inputs[c], inputs[d]),
ToInt64(low, high));
}
}
}
TEST(RunInt32PairSubWithSharedInput) {
TestInt32PairSubWithSharedInput(0, 0, 0, 0);
TestInt32PairSubWithSharedInput(1, 0, 0, 0);
TestInt32PairSubWithSharedInput(0, 1, 0, 0);
TestInt32PairSubWithSharedInput(0, 0, 1, 0);
TestInt32PairSubWithSharedInput(0, 0, 0, 1);
TestInt32PairSubWithSharedInput(1, 1, 0, 0);
}
[wasm] Int64Lowering of Int64Mul on ia32 and arm. Int64Mul is lowered to a new turbofan operator, Int32MulPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the multiplication. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1807273002 Cr-Commit-Position: refs/heads/master@{#35131}
2016-03-30 10:39:04 +00:00
TEST(RunInt32PairMul) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairMul = m.Int32PairMul(m.Parameter(0), m.Parameter(1), m.Parameter(2),
m.Parameter(3));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairMul));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairMul));
m.Return(m.Int32Constant(74));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32),
static_cast<uint32_t>(j & 0xFFFFFFFF),
static_cast<uint32_t>(j >> 32));
CHECK_EQ(i * j, ToInt64(low, high));
[wasm] Int64Lowering of Int64Mul on ia32 and arm. Int64Mul is lowered to a new turbofan operator, Int32MulPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the multiplication. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1807273002 Cr-Commit-Position: refs/heads/master@{#35131}
2016-03-30 10:39:04 +00:00
}
}
}
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
TEST(RunInt32PairMulUseOnlyHighWord) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
MachineType::Uint32());
m.Return(m.Projection(1, m.Int32PairMul(m.Parameter(0), m.Parameter(1),
m.Parameter(2), m.Parameter(3))));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
[turbofan] Fix -Wsign-compare warnings. BUG=v8:5614 Review-Url: https://codereview.chromium.org/2490973002 Cr-Commit-Position: refs/heads/master@{#40879}
2016-11-10 10:02:44 +00:00
CHECK_EQ(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
static_cast<uint32_t>((i * j) >> 32),
static_cast<uint32_t>(m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32),
static_cast<uint32_t>(j & 0xFFFFFFFF),
static_cast<uint32_t>(j >> 32))));
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
}
}
}
[wasm] Int64Lowering of Int64Mul on ia32 and arm. Int64Mul is lowered to a new turbofan operator, Int32MulPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the multiplication. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1807273002 Cr-Commit-Position: refs/heads/master@{#35131}
2016-03-30 10:39:04 +00:00
void TestInt32PairMulWithSharedInput(int a, int b, int c, int d) {
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairMul = m.Int32PairMul(m.Parameter(a), m.Parameter(b), m.Parameter(c),
m.Parameter(d));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairMul));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairMul));
m.Return(m.Int32Constant(74));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i, j);
uint32_t inputs[] = {i, j};
[wasm] Int64Lowering of Int64Mul on ia32 and arm. Int64Mul is lowered to a new turbofan operator, Int32MulPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the multiplication. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1807273002 Cr-Commit-Position: refs/heads/master@{#35131}
2016-03-30 10:39:04 +00:00
CHECK_EQ(ToInt64(inputs[a], inputs[b]) * ToInt64(inputs[c], inputs[d]),
ToInt64(low, high));
}
}
}
TEST(RunInt32PairMulWithSharedInput) {
TestInt32PairMulWithSharedInput(0, 0, 0, 0);
TestInt32PairMulWithSharedInput(1, 0, 0, 0);
TestInt32PairMulWithSharedInput(0, 1, 0, 0);
TestInt32PairMulWithSharedInput(0, 0, 1, 0);
TestInt32PairMulWithSharedInput(0, 0, 0, 1);
TestInt32PairMulWithSharedInput(1, 1, 0, 0);
TestInt32PairMulWithSharedInput(0, 1, 1, 0);
}
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
TEST(RunWord32PairShl) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
uint32_t high;
uint32_t low;
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
Node* PairShl =
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
m.Word32PairShl(m.Parameter(0), m.Parameter(1), m.Parameter(2));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
m.Projection(0, PairShl));
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
m.StoreToPointer(&high, MachineRepresentation::kWord32,
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
m.Projection(1, PairShl));
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
m.Return(m.Int32Constant(74));
[wasm] Int64Lowering of Int64Sub on ia32 and arm. Int64Sub is lowered to a new turbofan operator, Int32SubPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the subtraction. The implementation is very similar to the implementation of Int64Add. @v8-arm-ports: please take a careful look at the implementation of sbc in the simulator. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778893005 Cr-Commit-Position: refs/heads/master@{#34808}
2016-03-16 10:56:29 +00:00
FOR_UINT64_INPUTS(i) {
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
for (uint32_t j = 0; j < 64; j++) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32), j);
CHECK_EQ(i << j, ToInt64(low, high));
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
}
}
}
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
TEST(RunWord32PairShlUseOnlyHighWord) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
m.Return(m.Projection(
1, m.Word32PairShl(m.Parameter(0), m.Parameter(1), m.Parameter(2))));
FOR_UINT64_INPUTS(i) {
for (uint32_t j = 0; j < 64; j++) {
[turbofan] Fix -Wsign-compare warnings. BUG=v8:5614 Review-Url: https://codereview.chromium.org/2490973002 Cr-Commit-Position: refs/heads/master@{#40879}
2016-11-10 10:02:44 +00:00
CHECK_EQ(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
static_cast<uint32_t>((i << j) >> 32),
static_cast<uint32_t>(m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32), j)));
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
}
}
}
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
void TestWord32PairShlWithSharedInput(int a, int b) {
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairAdd =
m.Word32PairShl(m.Parameter(a), m.Parameter(b), m.Parameter(1));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairAdd));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairAdd));
m.Return(m.Int32Constant(74));
FOR_UINT32_INPUTS(i) {
for (uint32_t j = 0; j < 64; j++) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i, j);
uint32_t inputs[] = {i, j};
[wasm] Fixed register allocation for Word32PairShl on arm. The previous register allocation allowed invalid register aliasing in cases where in the TF graph the node was used for multiple inputs of the Word32PairShl node. Additionally I renamed PairLsl to LslPair in the code generation for consistency. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1776393004 Cr-Commit-Position: refs/heads/master@{#34755}
2016-03-14 17:22:27 +00:00
CHECK_EQ(ToInt64(inputs[a], inputs[b]) << j, ToInt64(low, high));
}
}
}
TEST(RunWord32PairShlWithSharedInput) {
TestWord32PairShlWithSharedInput(0, 0);
TestWord32PairShlWithSharedInput(0, 1);
TestWord32PairShlWithSharedInput(1, 0);
TestWord32PairShlWithSharedInput(1, 1);
}
MIPS: [wasm] Lowering of Int64Shl, Int64Shr, Int64Sar, Int64Add and Int64Sub. Implementation of turbofan operators Word32PairShl, Word32PairShr, Word32PairSar, Int32AddPair and Int32SubPair for MIPS. Port of: https://codereview.chromium.org/1765973002/ https://codereview.chromium.org/1778893004/ https://codereview.chromium.org/1778493004/ https://codereview.chromium.org/1778893005/ https://codereview.chromium.org/1842013002/ Added tests for Word32PairShr and Word32PairSar in test-run-machops.cc. BUG= Review URL: https://codereview.chromium.org/1819383002 Cr-Commit-Position: refs/heads/master@{#35307}
2016-04-06 14:43:28 +00:00
TEST(RunWord32PairShr) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairAdd =
m.Word32PairShr(m.Parameter(0), m.Parameter(1), m.Parameter(2));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairAdd));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairAdd));
m.Return(m.Int32Constant(74));
FOR_UINT64_INPUTS(i) {
for (uint32_t j = 0; j < 64; j++) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32), j);
CHECK_EQ(i >> j, ToInt64(low, high));
MIPS: [wasm] Lowering of Int64Shl, Int64Shr, Int64Sar, Int64Add and Int64Sub. Implementation of turbofan operators Word32PairShl, Word32PairShr, Word32PairSar, Int32AddPair and Int32SubPair for MIPS. Port of: https://codereview.chromium.org/1765973002/ https://codereview.chromium.org/1778893004/ https://codereview.chromium.org/1778493004/ https://codereview.chromium.org/1778893005/ https://codereview.chromium.org/1842013002/ Added tests for Word32PairShr and Word32PairSar in test-run-machops.cc. BUG= Review URL: https://codereview.chromium.org/1819383002 Cr-Commit-Position: refs/heads/master@{#35307}
2016-04-06 14:43:28 +00:00
}
}
}
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
TEST(RunWord32PairShrUseOnlyHighWord) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
m.Return(m.Projection(
1, m.Word32PairShr(m.Parameter(0), m.Parameter(1), m.Parameter(2))));
FOR_UINT64_INPUTS(i) {
for (uint32_t j = 0; j < 64; j++) {
[turbofan] Fix -Wsign-compare warnings. BUG=v8:5614 Review-Url: https://codereview.chromium.org/2490973002 Cr-Commit-Position: refs/heads/master@{#40879}
2016-11-10 10:02:44 +00:00
CHECK_EQ(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
static_cast<uint32_t>((i >> j) >> 32),
static_cast<uint32_t>(m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32), j)));
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
}
}
}
MIPS: [wasm] Lowering of Int64Shl, Int64Shr, Int64Sar, Int64Add and Int64Sub. Implementation of turbofan operators Word32PairShl, Word32PairShr, Word32PairSar, Int32AddPair and Int32SubPair for MIPS. Port of: https://codereview.chromium.org/1765973002/ https://codereview.chromium.org/1778893004/ https://codereview.chromium.org/1778493004/ https://codereview.chromium.org/1778893005/ https://codereview.chromium.org/1842013002/ Added tests for Word32PairShr and Word32PairSar in test-run-machops.cc. BUG= Review URL: https://codereview.chromium.org/1819383002 Cr-Commit-Position: refs/heads/master@{#35307}
2016-04-06 14:43:28 +00:00
TEST(RunWord32PairSar) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
uint32_t high;
uint32_t low;
Node* PairAdd =
m.Word32PairSar(m.Parameter(0), m.Parameter(1), m.Parameter(2));
m.StoreToPointer(&low, MachineRepresentation::kWord32,
m.Projection(0, PairAdd));
m.StoreToPointer(&high, MachineRepresentation::kWord32,
m.Projection(1, PairAdd));
m.Return(m.Int32Constant(74));
FOR_INT64_INPUTS(i) {
for (uint32_t j = 0; j < 64; j++) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32), j);
CHECK_EQ(i >> j, static_cast<int64_t>(ToInt64(low, high)));
MIPS: [wasm] Lowering of Int64Shl, Int64Shr, Int64Sar, Int64Add and Int64Sub. Implementation of turbofan operators Word32PairShl, Word32PairShr, Word32PairSar, Int32AddPair and Int32SubPair for MIPS. Port of: https://codereview.chromium.org/1765973002/ https://codereview.chromium.org/1778893004/ https://codereview.chromium.org/1778493004/ https://codereview.chromium.org/1778893005/ https://codereview.chromium.org/1842013002/ Added tests for Word32PairShr and Word32PairSar in test-run-machops.cc. BUG= Review URL: https://codereview.chromium.org/1819383002 Cr-Commit-Position: refs/heads/master@{#35307}
2016-04-06 14:43:28 +00:00
}
}
}
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
TEST(RunWord32PairSarUseOnlyHighWord) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
m.Return(m.Projection(
1, m.Word32PairSar(m.Parameter(0), m.Parameter(1), m.Parameter(2))));
FOR_INT64_INPUTS(i) {
for (uint32_t j = 0; j < 64; j++) {
[turbofan] Fix -Wsign-compare warnings. BUG=v8:5614 Review-Url: https://codereview.chromium.org/2490973002 Cr-Commit-Position: refs/heads/master@{#40879}
2016-11-10 10:02:44 +00:00
CHECK_EQ(
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
static_cast<uint32_t>((i >> j) >> 32),
static_cast<uint32_t>(m.Call(static_cast<uint32_t>(i & 0xFFFFFFFF),
static_cast<uint32_t>(i >> 32), j)));
[wasm] Trim graph before scheduling. The scheduler expects a trimmed graph, so we have to trim the graph before scheduling. R=titzer@chromium.org, bmeurer@chromium.org TEST=cctest/test-run-wasm/RunWasmCompiled_GraphTrimming Review-Url: https://chromiumcodereview.appspot.com/2428443002 Cr-Commit-Position: refs/heads/master@{#40446}
2016-10-19 16:21:03 +00:00
}
}
}
[wasm] Int64Lowering of Int64Add on ia32 and arm. Int64Add is lowered to a new turbofan operator, Int32AddPair. The new operator takes 4 inputs an generates 2 outputs. The inputs are the low word of the left input, high word of the left input, the low word of the right input, and high word of the right input. The ouputs are the low and high word of the result of the addition. R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1778493004 Cr-Commit-Position: refs/heads/master@{#34747}
2016-03-14 15:33:15 +00:00
#endif
[turbofan] IA: TruncateFloat64ToFloat32 supports mem operand BUG= R=dcarney@chromium.org Review URL: https://codereview.chromium.org/639283003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24541 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-13 07:12:57 +00:00
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
TEST(RunDeadChangeFloat64ToInt32) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
RawMachineAssemblerTester<int32_t> m;
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
const int magic = 0x88ABCDA4;
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
m.ChangeFloat64ToInt32(m.Float64Constant(999.78));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
}
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
TEST(RunDeadChangeInt32ToFloat64) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
RawMachineAssemblerTester<int32_t> m;
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
const int magic = 0x8834ABCD;
TF: Rename ConvertXToY machine operators to ChangeXToY. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/435923002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22788 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 10:54:58 +00:00
m.ChangeInt32ToFloat64(m.Int32Constant(magic - 6888));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
}
TEST(RunLoopPhiInduction2) {
RawMachineAssemblerTester<int32_t> m;
int false_val = 0x10777;
// x = false_val; while(false) { x++; } return x;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* false_node = m.Int32Constant(false_val);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, false_node);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Int32Constant(0), &body, &end);
m.Bind(&body);
Node* add = m.Int32Add(phi, m.Int32Constant(1));
phi->ReplaceInput(1, add);
m.Goto(&header);
m.Bind(&end);
m.Return(phi);
CHECK_EQ(false_val, m.Call());
}
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
TEST(RunFloatDiamond) {
RawMachineAssemblerTester<int32_t> m;
const int magic = 99645;
float buffer = 0.1f;
float constant = 99.99f;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
Node* k1 = m.Float32Constant(constant);
Node* k2 = m.Float32Constant(0 - constant);
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&end);
m.Bind(&blockb);
m.Goto(&end);
m.Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kFloat32, k2, k1);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.Store(MachineRepresentation::kFloat32, m.PointerConstant(&buffer),
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.IntPtrConstant(0), phi, kNoWriteBarrier);
[turbofan] Add backend support for float32 operations. This adds the basics necessary to support float32 operations in TurboFan. The actual functionality required to detect safe float32 operations will be added based on this later. Therefore this does not affect production code except for some cleanup/refactoring. In detail, this patchset contains the following features: - Add support for float32 operations to arm, arm64, ia32 and x64 backends. - Add float32 machine operators. - Add support for float32 constants to simplified lowering. - Handle float32 representation for phis in simplified lowering. In addition, contains the following (related) cleanups: - Fix/unify naming of backend instructions. - Use AVX comparisons when available. - Extend ArchOpcodeField to 9 bits (required for arm64). - Refactor some code duplication in instruction selectors. BUG=v8:3589 LOG=n R=dcarney@chromium.org Review URL: https://codereview.chromium.org/1044793002 Cr-Commit-Position: refs/heads/master@{#27509}
2015-03-30 07:33:46 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
CHECK(constant == buffer);
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunDoubleDiamond) {
RawMachineAssemblerTester<int32_t> m;
const int magic = 99645;
double buffer = 0.1;
double constant = 99.99;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* k1 = m.Float64Constant(constant);
Node* k2 = m.Float64Constant(0 - constant);
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&end);
m.Bind(&blockb);
m.Goto(&end);
m.Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kFloat64, k2, k1);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&buffer),
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.Int32Constant(0), phi, kNoWriteBarrier);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
CHECK_EQ(constant, buffer);
}
TEST(RunRefDiamond) {
RawMachineAssemblerTester<int32_t> m;
const int magic = 99644;
Handle<String> rexpected =
CcTest::i_isolate()->factory()->InternalizeUtf8String("A");
[ubsan] Port Name/String/Symbol to the new design Bug: v8:3770 Change-Id: I4da6404aa968adca1fbb49029fc304622101d6c3 Reviewed-on: https://chromium-review.googlesource.com/c/1349112 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#57853}
2018-11-27 00:48:42 +00:00
String buffer;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* k1 = m.StringConstant("A");
Node* k2 = m.StringConstant("B");
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&end);
m.Bind(&blockb);
m.Goto(&end);
m.Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kTagged, k2, k1);
[ptr-compr] Fix tests that write tagged values to off-heap locations Bug: v8:7703 Change-Id: I8fa2659814f1d9585d0e2313540e8c11997eec6b Reviewed-on: https://chromium-review.googlesource.com/c/1459636 Commit-Queue: Igor Sheludko <ishell@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59507}
2019-02-11 15:31:20 +00:00
if (COMPRESS_POINTERS_BOOL) {
// Since |buffer| is located off-heap, use full pointer store.
m.Store(MachineType::PointerRepresentation(), m.PointerConstant(&buffer),
m.Int32Constant(0), m.BitcastTaggedToWord(phi), kNoWriteBarrier);
} else {
m.Store(MachineRepresentation::kTagged, m.PointerConstant(&buffer),
m.Int32Constant(0), phi, kNoWriteBarrier);
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
CHECK(rexpected->SameValue(buffer));
}
TEST(RunDoubleRefDiamond) {
RawMachineAssemblerTester<int32_t> m;
const int magic = 99648;
double dbuffer = 0.1;
double dconstant = 99.99;
Handle<String> rexpected =
CcTest::i_isolate()->factory()->InternalizeUtf8String("AX");
[ubsan] Port Name/String/Symbol to the new design Bug: v8:3770 Change-Id: I4da6404aa968adca1fbb49029fc304622101d6c3 Reviewed-on: https://chromium-review.googlesource.com/c/1349112 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#57853}
2018-11-27 00:48:42 +00:00
String rbuffer;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* d1 = m.Float64Constant(dconstant);
Node* d2 = m.Float64Constant(0 - dconstant);
Node* r1 = m.StringConstant("AX");
Node* r2 = m.StringConstant("BX");
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&end);
m.Bind(&blockb);
m.Goto(&end);
m.Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* dphi = m.Phi(MachineRepresentation::kFloat64, d2, d1);
Node* rphi = m.Phi(MachineRepresentation::kTagged, r2, r1);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&dbuffer),
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.Int32Constant(0), dphi, kNoWriteBarrier);
[ptr-compr] Fix tests that write tagged values to off-heap locations Bug: v8:7703 Change-Id: I8fa2659814f1d9585d0e2313540e8c11997eec6b Reviewed-on: https://chromium-review.googlesource.com/c/1459636 Commit-Queue: Igor Sheludko <ishell@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59507}
2019-02-11 15:31:20 +00:00
if (COMPRESS_POINTERS_BOOL) {
// Since |buffer| is located off-heap, use full pointer store.
m.Store(MachineType::PointerRepresentation(), m.PointerConstant(&rbuffer),
m.Int32Constant(0), m.BitcastTaggedToWord(rphi), kNoWriteBarrier);
} else {
m.Store(MachineRepresentation::kTagged, m.PointerConstant(&rbuffer),
m.Int32Constant(0), rphi, kNoWriteBarrier);
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
CHECK_EQ(dconstant, dbuffer);
CHECK(rexpected->SameValue(rbuffer));
}
TEST(RunDoubleRefDoubleDiamond) {
RawMachineAssemblerTester<int32_t> m;
const int magic = 99649;
double dbuffer = 0.1;
double dconstant = 99.997;
Handle<String> rexpected =
CcTest::i_isolate()->factory()->InternalizeUtf8String("AD");
[ubsan] Port Name/String/Symbol to the new design Bug: v8:3770 Change-Id: I4da6404aa968adca1fbb49029fc304622101d6c3 Reviewed-on: https://chromium-review.googlesource.com/c/1349112 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#57853}
2018-11-27 00:48:42 +00:00
String rbuffer;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, mid, blockd, blocke, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* d1 = m.Float64Constant(dconstant);
Node* d2 = m.Float64Constant(0 - dconstant);
Node* r1 = m.StringConstant("AD");
Node* r2 = m.StringConstant("BD");
m.Branch(m.Int32Constant(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&mid);
m.Bind(&blockb);
m.Goto(&mid);
m.Bind(&mid);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* dphi1 = m.Phi(MachineRepresentation::kFloat64, d2, d1);
Node* rphi1 = m.Phi(MachineRepresentation::kTagged, r2, r1);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Int32Constant(0), &blockd, &blocke);
m.Bind(&blockd);
m.Goto(&end);
m.Bind(&blocke);
m.Goto(&end);
m.Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* dphi2 = m.Phi(MachineRepresentation::kFloat64, d1, dphi1);
Node* rphi2 = m.Phi(MachineRepresentation::kTagged, r1, rphi1);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&dbuffer),
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.Int32Constant(0), dphi2, kNoWriteBarrier);
[ptr-compr] Fix tests that write tagged values to off-heap locations Bug: v8:7703 Change-Id: I8fa2659814f1d9585d0e2313540e8c11997eec6b Reviewed-on: https://chromium-review.googlesource.com/c/1459636 Commit-Queue: Igor Sheludko <ishell@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59507}
2019-02-11 15:31:20 +00:00
if (COMPRESS_POINTERS_BOOL) {
// Since |buffer| is located off-heap, use full pointer store.
m.Store(MachineType::PointerRepresentation(), m.PointerConstant(&rbuffer),
m.Int32Constant(0), m.BitcastTaggedToWord(rphi2), kNoWriteBarrier);
} else {
m.Store(MachineRepresentation::kTagged, m.PointerConstant(&rbuffer),
m.Int32Constant(0), rphi2, kNoWriteBarrier);
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
CHECK_EQ(dconstant, dbuffer);
CHECK(rexpected->SameValue(rbuffer));
}
TEST(RunDoubleLoopPhi) {
RawMachineAssemblerTester<int32_t> m;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int magic = 99773;
double buffer = 0.99;
double dconstant = 777.1;
Node* zero = m.Int32Constant(0);
Node* dk = m.Float64Constant(dconstant);
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kFloat64, dk, dk);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
phi->ReplaceInput(1, phi);
m.Branch(zero, &body, &end);
m.Bind(&body);
m.Goto(&header);
m.Bind(&end);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&buffer),
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.Int32Constant(0), phi, kNoWriteBarrier);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Int32Constant(magic));
CHECK_EQ(magic, m.Call());
}
TEST(RunCountToTenAccRaw) {
RawMachineAssemblerTester<int32_t> m;
Node* zero = m.Int32Constant(0);
Node* ten = m.Int32Constant(10);
Node* one = m.Int32Constant(1);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, body_cont, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* i = m.Phi(MachineRepresentation::kWord32, zero, zero);
Node* j = m.Phi(MachineRepresentation::kWord32, zero, zero);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&body);
m.Bind(&body);
Node* next_i = m.Int32Add(i, one);
Node* next_j = m.Int32Add(j, one);
m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
m.Bind(&body_cont);
i->ReplaceInput(1, next_i);
j->ReplaceInput(1, next_j);
m.Goto(&header);
m.Bind(&end);
m.Return(ten);
CHECK_EQ(10, m.Call());
}
TEST(RunCountToTenAccRaw2) {
RawMachineAssemblerTester<int32_t> m;
Node* zero = m.Int32Constant(0);
Node* ten = m.Int32Constant(10);
Node* one = m.Int32Constant(1);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel header, body, body_cont, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&header);
m.Bind(&header);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* i = m.Phi(MachineRepresentation::kWord32, zero, zero);
Node* j = m.Phi(MachineRepresentation::kWord32, zero, zero);
Node* k = m.Phi(MachineRepresentation::kWord32, zero, zero);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Goto(&body);
m.Bind(&body);
Node* next_i = m.Int32Add(i, one);
Node* next_j = m.Int32Add(j, one);
Node* next_k = m.Int32Add(j, one);
m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
m.Bind(&body_cont);
i->ReplaceInput(1, next_i);
j->ReplaceInput(1, next_j);
k->ReplaceInput(1, next_k);
m.Goto(&header);
m.Bind(&end);
m.Return(ten);
CHECK_EQ(10, m.Call());
}
TEST(RunAddTree) {
RawMachineAssemblerTester<int32_t> m;
int32_t inputs[] = {11, 12, 13, 14, 15, 16, 17, 18};
Node* base = m.PointerConstant(inputs);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* n0 =
m.Load(MachineType::Int32(), base, m.Int32Constant(0 * sizeof(int32_t)));
Node* n1 =
m.Load(MachineType::Int32(), base, m.Int32Constant(1 * sizeof(int32_t)));
Node* n2 =
m.Load(MachineType::Int32(), base, m.Int32Constant(2 * sizeof(int32_t)));
Node* n3 =
m.Load(MachineType::Int32(), base, m.Int32Constant(3 * sizeof(int32_t)));
Node* n4 =
m.Load(MachineType::Int32(), base, m.Int32Constant(4 * sizeof(int32_t)));
Node* n5 =
m.Load(MachineType::Int32(), base, m.Int32Constant(5 * sizeof(int32_t)));
Node* n6 =
m.Load(MachineType::Int32(), base, m.Int32Constant(6 * sizeof(int32_t)));
Node* n7 =
m.Load(MachineType::Int32(), base, m.Int32Constant(7 * sizeof(int32_t)));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* i1 = m.Int32Add(n0, n1);
Node* i2 = m.Int32Add(n2, n3);
Node* i3 = m.Int32Add(n4, n5);
Node* i4 = m.Int32Add(n6, n7);
Node* i5 = m.Int32Add(i1, i2);
Node* i6 = m.Int32Add(i3, i4);
Node* i7 = m.Int32Add(i5, i6);
m.Return(i7);
CHECK_EQ(116, m.Call());
}
static const int kFloat64CompareHelperTestCases = 15;
static const int kFloat64CompareHelperNodeType = 4;
static int Float64CompareHelper(RawMachineAssemblerTester<int32_t>* m,
int test_case, int node_type, double x,
double y) {
static double buffer[2];
buffer[0] = x;
buffer[1] = y;
CHECK(0 <= test_case && test_case < kFloat64CompareHelperTestCases);
CHECK(0 <= node_type && node_type < kFloat64CompareHelperNodeType);
CHECK(x < y);
bool load_a = node_type / 2 == 1;
bool load_b = node_type % 2 == 1;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* a =
load_a ? m->Load(MachineType::Float64(), m->PointerConstant(&buffer[0]))
: m->Float64Constant(x);
Node* b =
load_b ? m->Load(MachineType::Float64(), m->PointerConstant(&buffer[1]))
: m->Float64Constant(y);
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
Node* cmp = nullptr;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bool expected = false;
switch (test_case) {
// Equal tests.
case 0:
cmp = m->Float64Equal(a, b);
expected = false;
break;
case 1:
cmp = m->Float64Equal(a, a);
expected = true;
break;
// LessThan tests.
case 2:
cmp = m->Float64LessThan(a, b);
expected = true;
break;
case 3:
cmp = m->Float64LessThan(b, a);
expected = false;
break;
case 4:
cmp = m->Float64LessThan(a, a);
expected = false;
break;
// LessThanOrEqual tests.
case 5:
cmp = m->Float64LessThanOrEqual(a, b);
expected = true;
break;
case 6:
cmp = m->Float64LessThanOrEqual(b, a);
expected = false;
break;
case 7:
cmp = m->Float64LessThanOrEqual(a, a);
expected = true;
break;
// NotEqual tests.
case 8:
cmp = m->Float64NotEqual(a, b);
expected = true;
break;
case 9:
cmp = m->Float64NotEqual(b, a);
expected = true;
break;
case 10:
cmp = m->Float64NotEqual(a, a);
expected = false;
break;
// GreaterThan tests.
case 11:
cmp = m->Float64GreaterThan(a, a);
expected = false;
break;
case 12:
cmp = m->Float64GreaterThan(a, b);
expected = false;
break;
// GreaterThanOrEqual tests.
case 13:
cmp = m->Float64GreaterThanOrEqual(a, a);
expected = true;
break;
case 14:
cmp = m->Float64GreaterThanOrEqual(b, a);
expected = true;
break;
default:
UNREACHABLE();
}
m->Return(cmp);
return expected;
}
TEST(RunFloat64Compare) {
Revert of Remove obsolete V8_INFINITY macro. (patchset #3 id:40001 of https://codereview.chromium.org/798413003/) Reason for revert: Speculative revert. This seems to block the current roll: https://codereview.chromium.org/819653003/ I retried several times, also with a new roll. The error is internal - but that doesn't make much of a difference. Original issue's description: > Remove obsolete V8_INFINITY macro. > > Use std::numeric_limits consistently. > > R=svenpanne@chromium.org > > Committed: https://crrev.com/31c66e2d53569c4e229d55483d28208491e73612 > Cr-Commit-Position: refs/heads/master@{#25897} TBR=svenpanne@chromium.org,bmeurer@chromium.org NOTREECHECKS=true NOTRY=true Review URL: https://codereview.chromium.org/813813003 Cr-Commit-Position: refs/heads/master@{#25912}
2014-12-20 13:17:20 +00:00
double inf = V8_INFINITY;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
// All pairs (a1, a2) are of the form a1 < a2.
double inputs[] = {0.0, 1.0, -1.0, 0.22, -1.22, 0.22,
-inf, 0.22, 0.22, inf, -inf, inf};
for (int test = 0; test < kFloat64CompareHelperTestCases; test++) {
for (int node_type = 0; node_type < kFloat64CompareHelperNodeType;
node_type++) {
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t input = 0; input < arraysize(inputs); input += 2) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
RawMachineAssemblerTester<int32_t> m;
int expected = Float64CompareHelper(&m, test, node_type, inputs[input],
inputs[input + 1]);
CHECK_EQ(expected, m.Call());
}
}
}
}
TEST(RunFloat64UnorderedCompare) {
RawMachineAssemblerTester<int32_t> m;
[turbofan] Next step towards shared operators. TEST=compiler-unittests,cctest R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/555283004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23837 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-10 12:23:45 +00:00
const Operator* operators[] = {m.machine()->Float64Equal(),
m.machine()->Float64LessThan(),
m.machine()->Float64LessThanOrEqual()};
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Remove deprecated v8::base::OS::nan_value(). Use std::numeric_limits<double>::quiet_NaN() and std::numeric_limits<float>::quiet_NaN() instead. Review URL: https://codereview.chromium.org/864803002 Cr-Commit-Position: refs/heads/master@{#26195}
2015-01-21 14:38:49 +00:00
double nan = std::numeric_limits<double>::quiet_NaN();
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
FOR_FLOAT64_INPUTS(i) {
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t o = 0; o < arraysize(operators); ++o) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
for (int j = 0; j < 2; j++) {
RawMachineAssemblerTester<int32_t> m;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* a = m.Float64Constant(i);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* b = m.Float64Constant(nan);
if (j == 1) std::swap(a, b);
Reland "[turbofan] Checking of input counts on node creation" (Original CL: https://codereview.chromium.org/1347353003/) Unfortunately, the mips gcc gets confused by arraysize on variadic templated arguments, so we use sizeof... instead. Review URL: https://codereview.chromium.org/1366543003 Cr-Commit-Position: refs/heads/master@{#30880}
2015-09-23 09:08:15 +00:00
m.Return(m.AddNode(operators[o], a, b));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
CHECK_EQ(0, m.Call());
}
}
}
}
TEST(RunFloat64Equal) {
double input_a = 0.0;
double input_b = 0.0;
RawMachineAssemblerTester<int32_t> m;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* a = m.LoadFromPointer(&input_a, MachineType::Float64());
Node* b = m.LoadFromPointer(&input_b, MachineType::Float64());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Float64Equal(a, b));
CompareWrapper cmp(IrOpcode::kFloat64Equal);
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
input_a = pl;
input_b = pr;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
CHECK_EQ(expected, m.Call());
}
}
}
TEST(RunFloat64LessThan) {
double input_a = 0.0;
double input_b = 0.0;
RawMachineAssemblerTester<int32_t> m;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* a = m.LoadFromPointer(&input_a, MachineType::Float64());
Node* b = m.LoadFromPointer(&input_b, MachineType::Float64());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(m.Float64LessThan(a, b));
CompareWrapper cmp(IrOpcode::kFloat64LessThan);
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
input_a = pl;
input_b = pr;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
CHECK_EQ(expected, m.Call());
}
}
}
static void IntPtrCompare(intptr_t left, intptr_t right) {
for (int test = 0; test < 7; test++) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<bool> m(MachineType::Pointer(),
MachineType::Pointer());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* p0 = m.Parameter(0);
Node* p1 = m.Parameter(1);
Use nullptr instead of NULL where possible New code should use nullptr instead of NULL. This patch updates existing use of NULL to nullptr where applicable, making the code base more consistent. BUG=v8:6928,v8:6921 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng;master.tryserver.v8:v8_linux_noi18n_rel_ng Change-Id: I4687f5b96fcfd88b41fa970a2b937b4f6538777c Reviewed-on: https://chromium-review.googlesource.com/718338 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#48557}
2017-10-13 16:33:03 +00:00
Node* res = nullptr;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
bool expected = false;
switch (test) {
case 0:
res = m.IntPtrLessThan(p0, p1);
expected = true;
break;
case 1:
res = m.IntPtrLessThanOrEqual(p0, p1);
expected = true;
break;
case 2:
res = m.IntPtrEqual(p0, p1);
expected = false;
break;
case 3:
res = m.IntPtrGreaterThanOrEqual(p0, p1);
expected = false;
break;
case 4:
res = m.IntPtrGreaterThan(p0, p1);
expected = false;
break;
case 5:
res = m.IntPtrEqual(p0, p0);
expected = true;
break;
case 6:
res = m.IntPtrNotEqual(p0, p1);
expected = true;
break;
default:
UNREACHABLE();
break;
}
m.Return(res);
CHECK_EQ(expected, m.Call(reinterpret_cast<int32_t*>(left),
reinterpret_cast<int32_t*>(right)));
}
}
TEST(RunIntPtrCompare) {
intptr_t min = std::numeric_limits<intptr_t>::min();
intptr_t max = std::numeric_limits<intptr_t>::max();
// An ascending chain of intptr_t
intptr_t inputs[] = {min, min / 2, -1, 0, 1, max / 2, max};
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t i = 0; i < arraysize(inputs) - 1; i++) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
IntPtrCompare(inputs[i], inputs[i + 1]);
}
}
TEST(RunTestIntPtrArithmetic) {
static const int kInputSize = 10;
int32_t inputs[kInputSize];
int32_t outputs[kInputSize];
for (int i = 0; i < kInputSize; i++) {
inputs[i] = i;
outputs[i] = -1;
}
RawMachineAssemblerTester<int32_t*> m;
Node* input = m.PointerConstant(&inputs[0]);
Node* output = m.PointerConstant(&outputs[kInputSize - 1]);
[turbofan] Clean up cctest "framework" for dealing with native calls. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1164603002 Cr-Commit-Position: refs/heads/master@{#28703}
2015-05-29 14:05:39 +00:00
Node* elem_size = m.IntPtrConstant(sizeof(inputs[0]));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
for (int i = 0; i < kInputSize; i++) {
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.Store(MachineRepresentation::kWord32, output,
m.Load(MachineType::Int32(), input), kNoWriteBarrier);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
input = m.IntPtrAdd(input, elem_size);
output = m.IntPtrSub(output, elem_size);
}
m.Return(input);
CHECK_EQ(&inputs[kInputSize], m.Call());
for (int i = 0; i < kInputSize; i++) {
CHECK_EQ(i, inputs[i]);
CHECK_EQ(kInputSize - i - 1, outputs[i]);
}
[arm] Add support for ROR. Refactor operand2 handling. This was the last missing bit for full "flexible second operand" / operand2 support on ARM. TEST=cctest/test-instruction-selector-arm,cctest/test-run-machops R=jarin@chromium.org Review URL: https://codereview.chromium.org/434553002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22732 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-31 07:44:29 +00:00
}
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
TEST(RunSpillLotsOfThings) {
static const int kInputSize = 1000;
[turbofan] Tester improvements; use CSignature and simplify ReturnValueTraits. R=bmeurer@chromium.org,mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1150083006 Cr-Commit-Position: refs/heads/master@{#28733}
2015-06-01 15:54:53 +00:00
RawMachineAssemblerTester<int32_t> m;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Node* accs[kInputSize];
int32_t outputs[kInputSize];
Node* one = m.Int32Constant(1);
Node* acc = one;
for (int i = 0; i < kInputSize; i++) {
acc = m.Int32Add(acc, one);
accs[i] = acc;
}
for (int i = 0; i < kInputSize; i++) {
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&outputs[i], MachineRepresentation::kWord32, accs[i]);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
m.Return(one);
m.Call();
for (int i = 0; i < kInputSize; i++) {
CHECK_EQ(outputs[i], i + 2);
}
}
TEST(RunSpillConstantsAndParameters) {
Fix 64-bit VS2010 build R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/420033003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22722 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 16:21:36 +00:00
static const int kInputSize = 1000;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
static const int32_t kBase = 987;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
int32_t outputs[kInputSize];
Node* csts[kInputSize];
Node* accs[kInputSize];
Node* acc = m.Int32Constant(0);
Fix 64-bit VS2010 build R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/420033003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22722 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 16:21:36 +00:00
for (int i = 0; i < kInputSize; i++) {
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
csts[i] = m.Int32Constant(base::AddWithWraparound(kBase, i));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
Fix 64-bit VS2010 build R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/420033003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22722 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 16:21:36 +00:00
for (int i = 0; i < kInputSize; i++) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
acc = m.Int32Add(acc, csts[i]);
accs[i] = acc;
}
Fix 64-bit VS2010 build R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/420033003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22722 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 16:21:36 +00:00
for (int i = 0; i < kInputSize; i++) {
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&outputs[i], MachineRepresentation::kWord32, accs[i]);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
m.Return(m.Int32Add(acc, m.Int32Add(m.Parameter(0), m.Parameter(1))));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t expected = base::AddWithWraparound(i, j);
Fix 64-bit VS2010 build R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/420033003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22722 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 16:21:36 +00:00
for (int k = 0; k < kInputSize; k++) {
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
expected = base::AddWithWraparound(expected, kBase + k);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
}
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_EQ(expected, m.Call(i, j));
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
expected = 0;
Fix 64-bit VS2010 build R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/420033003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22722 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 16:21:36 +00:00
for (int k = 0; k < kInputSize; k++) {
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
expected += kBase + k;
CHECK_EQ(expected, outputs[k]);
}
}
}
}
TEST(RunNewSpaceConstantsInPhi) {
[ubsan] Port Object to the new design Tbr: ahaas@chromium.org,leszeks@chromium.org,verwaest@chromium.org Bug: v8:3770 Change-Id: Ia6530fbb70dac05e9972283781c3550d8b50e1eb Reviewed-on: https://chromium-review.googlesource.com/c/1390116 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Alexei Filippov <alph@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Sigurd Schneider <sigurds@chromium.org> Cr-Commit-Position: refs/heads/master@{#58470}
2018-12-25 00:19:47 +00:00
RawMachineAssemblerTester<Object> m(MachineType::Int32());
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
Isolate* isolate = CcTest::i_isolate();
Handle<HeapNumber> true_val = isolate->factory()->NewHeapNumber(11.2);
Handle<HeapNumber> false_val = isolate->factory()->NewHeapNumber(11.3);
Node* true_node = m.HeapConstant(true_val);
Node* false_node = m.HeapConstant(false_val);
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb, end;
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Branch(m.Parameter(0), &blocka, &blockb);
m.Bind(&blocka);
m.Goto(&end);
m.Bind(&blockb);
m.Goto(&end);
m.Bind(&end);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = m.Phi(MachineRepresentation::kTagged, true_node, false_node);
Land the Fan (disabled) R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/426233002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22709 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-07-30 13:54:45 +00:00
m.Return(phi);
CHECK_EQ(*false_val, m.Call(0));
CHECK_EQ(*true_val, m.Call(1));
}
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
TEST(RunInt32AddWithOverflowP) {
int32_t actual_val = -1;
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
bt.AddReturn(ovf);
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
int32_t expected_val;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, bt.call(i, j));
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt32AddWithOverflowImm) {
int32_t actual_val = -1, expected_val = 0;
FOR_INT32_INPUTS(i) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int32AddWithOverflow(m.Int32Constant(i), m.Parameter(0));
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
m.Return(ovf);
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int32AddWithOverflow(m.Parameter(0), m.Int32Constant(i));
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
m.Return(ovf);
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
FOR_INT32_INPUTS(j) {
RawMachineAssemblerTester<int32_t> m;
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* add =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int32AddWithOverflow(m.Int32Constant(i), m.Int32Constant(j));
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
m.Return(ovf);
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedAddOverflow32(i, j, &expected_val);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
CHECK_EQ(expected_ovf, m.Call());
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt32AddWithOverflowInBranchP) {
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
int constant = 911777;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
Node* ovf = m.Projection(1, add);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
m.Branch(ovf, &blocka, &blockb);
m.Bind(&blocka);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
bt.AddReturn(m.Int32Constant(constant));
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
m.Bind(&blockb);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
bt.AddReturn(val);
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
int32_t expected;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (base::bits::SignedAddOverflow32(i, j, &expected)) expected = constant;
CHECK_EQ(expected, bt.call(i, j));
[turbofan] Add Int32AddWithOverflow machine operator. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/436593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22784 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 09:32:58 +00:00
}
}
}
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
TEST(RunInt32SubWithOverflowP) {
int32_t actual_val = -1;
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* add = m.Int32SubWithOverflow(bt.param0, bt.param1);
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
bt.AddReturn(ovf);
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
int32_t expected_val;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, bt.call(i, j));
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt32SubWithOverflowImm) {
int32_t actual_val = -1, expected_val = 0;
FOR_INT32_INPUTS(i) {
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int32SubWithOverflow(m.Int32Constant(i), m.Parameter(0));
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
m.Return(ovf);
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
{
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int32SubWithOverflow(m.Parameter(0), m.Int32Constant(i));
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
m.Return(ovf);
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow32(j, i, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
CHECK_EQ(expected_val, actual_val);
}
}
FOR_INT32_INPUTS(j) {
RawMachineAssemblerTester<int32_t> m;
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* add =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int32SubWithOverflow(m.Int32Constant(i), m.Int32Constant(j));
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
m.Return(ovf);
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedSubOverflow32(i, j, &expected_val);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
CHECK_EQ(expected_ovf, m.Call());
CHECK_EQ(expected_val, actual_val);
}
}
}
TEST(RunInt32SubWithOverflowInBranchP) {
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
int constant = 911999;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* sub = m.Int32SubWithOverflow(bt.param0, bt.param1);
Node* ovf = m.Projection(1, sub);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
m.Branch(ovf, &blocka, &blockb);
m.Bind(&blocka);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
bt.AddReturn(m.Int32Constant(constant));
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
m.Bind(&blockb);
[turbofan] Support for combining branches with <Operation>WithOverflow. Also unify the handling of binops in the InstructionSelector backends. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/415403005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22800 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-04 08:18:37 +00:00
Node* val = m.Projection(0, sub);
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
bt.AddReturn(val);
Unify MachineType and RepType. MachineType now tracks both the representation and the value type of machine quantities and is used uniformly throughout TurboFan. These types can now express uint8, int8, uint16, and int16, i.e. signed and unsigned smallish integers. Note that currently only uint8 and uint16 are implemented in the TF backends. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/470593002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-14 09:19:54 +00:00
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
int32_t expected;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (base::bits::SignedSubOverflow32(i, j, &expected)) expected = constant;
CHECK_EQ(expected, bt.call(i, j));
[turbofan] Add support for Int32SubWithOverflow. TEST=cctest/test-run-machops,cctest/test-instruction-selector-arm R=titzer@chromium.org Review URL: https://codereview.chromium.org/432373002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22791 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-01 12:18:20 +00:00
}
}
}
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
TEST(RunInt32MulWithOverflowP) {
int32_t actual_val = -1;
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
Node* add = m.Int32MulWithOverflow(bt.param0, bt.param1);
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
bt.AddReturn(ovf);
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
int32_t expected_val;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedMulOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, bt.call(i, j));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
if (!expected_ovf) {
CHECK_EQ(expected_val, actual_val);
}
}
}
}
TEST(RunInt32MulWithOverflowImm) {
int32_t actual_val = -1, expected_val = 0;
FOR_INT32_INPUTS(i) {
{
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int32MulWithOverflow(m.Int32Constant(i), m.Parameter(0));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
m.Return(ovf);
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedMulOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
if (!expected_ovf) {
CHECK_EQ(expected_val, actual_val);
}
}
}
{
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
Node* add = m.Int32MulWithOverflow(m.Parameter(0), m.Int32Constant(i));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
m.Return(ovf);
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedMulOverflow32(i, j, &expected_val);
CHECK_EQ(expected_ovf, m.Call(j));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
if (!expected_ovf) {
CHECK_EQ(expected_val, actual_val);
}
}
}
FOR_INT32_INPUTS(j) {
RawMachineAssemblerTester<int32_t> m;
Node* add =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Int32MulWithOverflow(m.Int32Constant(i), m.Int32Constant(j));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
Node* val = m.Projection(0, add);
Node* ovf = m.Projection(1, add);
m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val);
m.Return(ovf);
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int expected_ovf = base::bits::SignedMulOverflow32(i, j, &expected_val);
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
CHECK_EQ(expected_ovf, m.Call());
if (!expected_ovf) {
CHECK_EQ(expected_val, actual_val);
}
}
}
}
TEST(RunInt32MulWithOverflowInBranchP) {
int constant = 911777;
RawMachineLabel blocka, blockb;
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
Node* add = m.Int32MulWithOverflow(bt.param0, bt.param1);
Node* ovf = m.Projection(1, add);
m.Branch(ovf, &blocka, &blockb);
m.Bind(&blocka);
bt.AddReturn(m.Int32Constant(constant));
m.Bind(&blockb);
Node* val = m.Projection(0, add);
bt.AddReturn(val);
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
int32_t expected;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (base::bits::SignedMulOverflow32(i, j, &expected)) expected = constant;
CHECK_EQ(expected, bt.call(i, j));
[turbofan] Introduce integer multiplication with overflow. BUG= Review-Url: https://codereview.chromium.org/2101123005 Cr-Commit-Position: refs/heads/master@{#37748}
2016-07-14 08:53:06 +00:00
}
}
}
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
TEST(RunWord64EqualInBranchP) {
int64_t input;
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel blocka, blockb;
[simulator] Make Call variadic In order to remove the CALL_GENERATED_CODE macro, it helps a lot to unify the interfaces of the simulators and make the Call method variadic in the number of arguments. This CL does that for each simulator. A follow-up CL will then completely remove the CALL_GENERATED_CODE macro and replace uses with the (new) GeneratedCode wrapper. R=mstarzinger@chromium.org Bug: v8:7182 Change-Id: I1f81445ec2faba30f0bd233b022ae1f0fae4e96f Reviewed-on: https://chromium-review.googlesource.com/850873 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#50413}
2018-01-08 15:31:30 +00:00
RawMachineAssemblerTester<int32_t> m;
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
if (!m.machine()->Is64()) return;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* value = m.LoadFromPointer(&input, MachineType::Int64());
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
m.Branch(m.Word64Equal(value, m.Int64Constant(0)), &blocka, &blockb);
m.Bind(&blocka);
m.Return(m.Int32Constant(1));
m.Bind(&blockb);
m.Return(m.Int32Constant(2));
[cleanup] Replace V8_INT64_C macro by proper C++11 syntax Some uses use uint64_t instead of int64_t to avoid compiler warnings about illegal narrowing of values with the MSB set. R=tebbi@chromium.org,mlippautz@chromium.org Bug: v8:7109 Change-Id: I6e861f48828bd931c451ef336672a260c13ae042 Reviewed-on: https://chromium-review.googlesource.com/803275 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Lippautz <mlippautz@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#49797}
2017-12-01 14:01:22 +00:00
input = int64_t{0};
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
CHECK_EQ(1, m.Call());
[cleanup] Replace V8_INT64_C macro by proper C++11 syntax Some uses use uint64_t instead of int64_t to avoid compiler warnings about illegal narrowing of values with the MSB set. R=tebbi@chromium.org,mlippautz@chromium.org Bug: v8:7109 Change-Id: I6e861f48828bd931c451ef336672a260c13ae042 Reviewed-on: https://chromium-review.googlesource.com/803275 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Lippautz <mlippautz@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#49797}
2017-12-01 14:01:22 +00:00
input = int64_t{1};
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
CHECK_EQ(2, m.Call());
[cleanup] Replace V8_INT64_C macro by proper C++11 syntax Some uses use uint64_t instead of int64_t to avoid compiler warnings about illegal narrowing of values with the MSB set. R=tebbi@chromium.org,mlippautz@chromium.org Bug: v8:7109 Change-Id: I6e861f48828bd931c451ef336672a260c13ae042 Reviewed-on: https://chromium-review.googlesource.com/803275 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Lippautz <mlippautz@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#49797}
2017-12-01 14:01:22 +00:00
input = int64_t{0x100000000};
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
CHECK_EQ(2, m.Call());
}
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
TEST(RunChangeInt32ToInt64P) {
[cleanup] Fix kPointerSize in tests Bug: v8:8477, v8:8834 Change-Id: I9213cca077a2758b87a6cb95bcb01d0186c32098 Reviewed-on: https://chromium-review.googlesource.com/c/1472633 Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Commit-Queue: Igor Sheludko <ishell@chromium.org> Cr-Commit-Position: refs/heads/master@{#59602}
2019-02-14 13:01:52 +00:00
if (kSystemPointerSize < 8) return;
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
int64_t actual = -1;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual, MachineRepresentation::kWord64,
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.ChangeInt32ToInt64(m.Parameter(0)));
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
m.Return(m.Int32Constant(0));
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int64_t expected = i;
CHECK_EQ(0, m.Call(i));
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
CHECK_EQ(expected, actual);
}
}
TEST(RunChangeUint32ToUint64P) {
[cleanup] Fix kPointerSize in tests Bug: v8:8477, v8:8834 Change-Id: I9213cca077a2758b87a6cb95bcb01d0186c32098 Reviewed-on: https://chromium-review.googlesource.com/c/1472633 Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Commit-Queue: Igor Sheludko <ishell@chromium.org> Cr-Commit-Position: refs/heads/master@{#59602}
2019-02-14 13:01:52 +00:00
if (kSystemPointerSize < 8) return;
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
int64_t actual = -1;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&actual, MachineRepresentation::kWord64,
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
m.ChangeUint32ToUint64(m.Parameter(0)));
m.Return(m.Int32Constant(0));
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int64_t expected = static_cast<uint64_t>(i);
CHECK_EQ(0, m.Call(i));
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
CHECK_EQ(expected, actual);
}
}
TEST(RunTruncateInt64ToInt32P) {
[cleanup] Fix kPointerSize in tests Bug: v8:8477, v8:8834 Change-Id: I9213cca077a2758b87a6cb95bcb01d0186c32098 Reviewed-on: https://chromium-review.googlesource.com/c/1472633 Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Commit-Queue: Igor Sheludko <ishell@chromium.org> Cr-Commit-Position: refs/heads/master@{#59602}
2019-02-14 13:01:52 +00:00
if (kSystemPointerSize < 8) return;
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
int64_t expected = -1;
RawMachineAssemblerTester<int32_t> m;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.Return(m.TruncateInt64ToInt32(
m.LoadFromPointer(&expected, MachineType::Int64())));
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
expected = (static_cast<uint64_t>(j) << 32) | i;
Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.". R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/877753007 Cr-Commit-Position: refs/heads/master@{#26346}
2015-01-30 09:29:25 +00:00
CHECK_EQ(static_cast<int32_t>(expected), m.Call());
[turbofan] Add proper conversion operators for int32<->int64. This affects arm64 and x64. Note that we do not yet optimize these conversions. Later we will add support for merging these conversion operators into other operations during instruction selection. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/487723002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23184 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-19 08:48:41 +00:00
}
}
}
[turbofan] Introduce TruncateTaggedToWord32 simplified operator. This allows us to get rid of the "push TruncateFloat64ToInt32 into Phi" trick that was used in the MachineOperatorReducer to combine the ChangeTaggedToFloat64 and TruncateFloat64ToInt32 operations. Instead of doing that later, we can just introduce the proper operator during the representation selection directly. Also separate the TruncateFloat64ToInt32 machine operator, which had two different meanings depending on a flag (either JavaScript truncation or C++ style round to zero). Now there's a TruncateFloat64ToWord32 which represents the JavaScript truncation (implemented via TruncateDoubleToI macro + code stub) and the RoundFloat64ToInt32, which implements the C++ round towards zero operation (in the same style as the other WebAssembly driven Round* machine operators). R=jarin@chromium.org Review URL: https://codereview.chromium.org/1919513002 Cr-Commit-Position: refs/heads/master@{#35743}
2016-04-24 11:39:31 +00:00
TEST(RunTruncateFloat64ToWord32P) {
[turbofan] Add TruncateFloat64ToInt32 machine operator. Fix ChangeLowering to use TruncateFloat64ToInt32. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/484103002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23214 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-20 04:01:00 +00:00
struct {
double from;
double raw;
} kValues[] = {{0, 0},
{0.5, 0},
{-0.5, 0},
{1.5, 1},
{-1.5, -1},
{5.5, 5},
{-5.0, -5},
Remove deprecated v8::base::OS::nan_value(). Use std::numeric_limits<double>::quiet_NaN() and std::numeric_limits<float>::quiet_NaN() instead. Review URL: https://codereview.chromium.org/864803002 Cr-Commit-Position: refs/heads/master@{#26195}
2015-01-21 14:38:49 +00:00
{std::numeric_limits<double>::quiet_NaN(), 0},
[turbofan] Add TruncateFloat64ToInt32 machine operator. Fix ChangeLowering to use TruncateFloat64ToInt32. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/484103002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23214 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-20 04:01:00 +00:00
{std::numeric_limits<double>::infinity(), 0},
Remove deprecated v8::base::OS::nan_value(). Use std::numeric_limits<double>::quiet_NaN() and std::numeric_limits<float>::quiet_NaN() instead. Review URL: https://codereview.chromium.org/864803002 Cr-Commit-Position: refs/heads/master@{#26195}
2015-01-21 14:38:49 +00:00
{-std::numeric_limits<double>::quiet_NaN(), 0},
[turbofan] Add TruncateFloat64ToInt32 machine operator. Fix ChangeLowering to use TruncateFloat64ToInt32. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/484103002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23214 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-20 04:01:00 +00:00
{-std::numeric_limits<double>::infinity(), 0},
{4.94065645841e-324, 0},
{-4.94065645841e-324, 0},
{0.9999999999999999, 0},
{-0.9999999999999999, 0},
{4294967296.0, 0},
{-4294967296.0, 0},
{9223372036854775000.0, 4294966272.0},
{-9223372036854775000.0, -4294966272.0},
{4.5036e+15, 372629504},
{-4.5036e+15, -372629504},
{287524199.5377777, 0x11234567},
{-287524199.5377777, -0x11234567},
{2300193596.302222, 2300193596.0},
{-2300193596.302222, -2300193596.0},
{4600387192.604444, 305419896},
{-4600387192.604444, -305419896},
{4823855600872397.0, 1737075661},
{-4823855600872397.0, -1737075661},
{4503603922337791.0, -1},
{-4503603922337791.0, 1},
{4503601774854143.0, 2147483647},
{-4503601774854143.0, -2147483647},
{9007207844675582.0, -2},
{-9007207844675582.0, 2},
{2.4178527921507624e+24, -536870912},
{-2.4178527921507624e+24, 536870912},
{2.417853945072267e+24, -536870912},
{-2.417853945072267e+24, 536870912},
{4.8357055843015248e+24, -1073741824},
{-4.8357055843015248e+24, 1073741824},
{4.8357078901445341e+24, -1073741824},
{-4.8357078901445341e+24, 1073741824},
{2147483647.0, 2147483647.0},
{-2147483648.0, -2147483648.0},
{9.6714111686030497e+24, -2147483648.0},
{-9.6714111686030497e+24, -2147483648.0},
{9.6714157802890681e+24, -2147483648.0},
{-9.6714157802890681e+24, -2147483648.0},
{1.9342813113834065e+25, 2147483648.0},
{-1.9342813113834065e+25, 2147483648.0},
{3.868562622766813e+25, 0},
{-3.868562622766813e+25, 0},
{1.7976931348623157e+308, 0},
{-1.7976931348623157e+308, 0}};
double input = -1.0;
RawMachineAssemblerTester<int32_t> m;
[turbofan] Introduce TruncateTaggedToWord32 simplified operator. This allows us to get rid of the "push TruncateFloat64ToInt32 into Phi" trick that was used in the MachineOperatorReducer to combine the ChangeTaggedToFloat64 and TruncateFloat64ToInt32 operations. Instead of doing that later, we can just introduce the proper operator during the representation selection directly. Also separate the TruncateFloat64ToInt32 machine operator, which had two different meanings depending on a flag (either JavaScript truncation or C++ style round to zero). Now there's a TruncateFloat64ToWord32 which represents the JavaScript truncation (implemented via TruncateDoubleToI macro + code stub) and the RoundFloat64ToInt32, which implements the C++ round towards zero operation (in the same style as the other WebAssembly driven Round* machine operators). R=jarin@chromium.org Review URL: https://codereview.chromium.org/1919513002 Cr-Commit-Position: refs/heads/master@{#35743}
2016-04-24 11:39:31 +00:00
m.Return(m.TruncateFloat64ToWord32(
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.LoadFromPointer(&input, MachineType::Float64())));
Replace our homegrown ARRAY_SIZE() with Chrome's arraysize(). Our own ARRAY_SIZE() was pretty bad at error checking. If you use arrasize() in a wrong way, the compiler will issue an error instead of silently doing the wrong thing. The previous ARRAY_SIZE() macro is still available as ARRAYSIZE_UNSAFE() similar to Chrome. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/501323002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23389 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-26 09:19:24 +00:00
for (size_t i = 0; i < arraysize(kValues); ++i) {
[turbofan] Add TruncateFloat64ToInt32 machine operator. Fix ChangeLowering to use TruncateFloat64ToInt32. TEST=cctest,compiler-unittests R=jarin@chromium.org Review URL: https://codereview.chromium.org/484103002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23214 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-08-20 04:01:00 +00:00
input = kValues[i].from;
uint64_t expected = static_cast<int64_t>(kValues[i].raw);
CHECK_EQ(static_cast<int>(expected), m.Call());
}
}
[x64] Regression test for https://codereview.chromium.org/1877133004 R=jkummerow@chromium.org Review URL: https://codereview.chromium.org/1919263002 Cr-Commit-Position: refs/heads/master@{#35807}
2016-04-27 06:59:47 +00:00
TEST(RunTruncateFloat64ToWord32SignExtension) {
BufferedRawMachineAssemblerTester<int32_t> r;
r.Return(r.Int32Sub(r.TruncateFloat64ToWord32(r.Float64Constant(-1.0)),
r.Int32Constant(0)));
CHECK_EQ(-1, r.Call());
}
[turbofan] Add backend support for float32. LOG=n BUG=v8:3589 TEST=compiler-unittests,cctest R=titzer@chromium.org Review URL: https://codereview.chromium.org/596703004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24179 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-24 11:08:35 +00:00
TEST(RunChangeFloat32ToFloat64) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float32());
[turbofan]IA: ChangeFloat32ToFloat64 supports mem operand BUG= R=titzer@chromium.org Review URL: https://codereview.chromium.org/641153003 Patch from Jing Bao <jing.bao@intel.com>. git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24542 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-13 07:42:35 +00:00
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0)));
[turbofan]IA: ChangeFloat32ToFloat64 supports mem operand BUG= R=titzer@chromium.org Review URL: https://codereview.chromium.org/641153003 Patch from Jing Bao <jing.bao@intel.com>. git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24542 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-13 07:42:35 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(i), m.Call(i)); }
[turbofan] Add backend support for float32. LOG=n BUG=v8:3589 TEST=compiler-unittests,cctest R=titzer@chromium.org Review URL: https://codereview.chromium.org/596703004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24179 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-24 11:08:35 +00:00
}
[turbofan] Add backend support for Float32Constant. TEST=cctest,compiler-unittests,mjsunit BUG=v8:3589 LOG=n R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/600383002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24217 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-25 08:56:02 +00:00
TEST(RunFloat32Constant) {
FOR_FLOAT32_INPUTS(i) {
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
BufferedRawMachineAssemblerTester<float> m;
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Return(m.Float32Constant(i));
CHECK_FLOAT_EQ(i, m.Call());
[turbofan] Add backend support for Float32Constant. TEST=cctest,compiler-unittests,mjsunit BUG=v8:3589 LOG=n R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/600383002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24217 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-25 08:56:02 +00:00
}
}
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
TEST(RunFloat64ExtractLowWord32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float64ExtractLowWord32(m.Parameter(0)));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = static_cast<uint32_t>(bit_cast<uint64_t>(i));
CHECK_EQ(expected, m.Call(i));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
}
}
TEST(RunFloat64ExtractHighWord32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float64ExtractHighWord32(m.Parameter(0)));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint32_t expected = static_cast<uint32_t>(bit_cast<uint64_t>(i) >> 32);
CHECK_EQ(expected, m.Call(i));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
}
}
TEST(RunFloat64InsertLowWord32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Int32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float64InsertLowWord32(m.Parameter(0), m.Parameter(1)));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
FOR_FLOAT64_INPUTS(i) {
FOR_INT32_INPUTS(j) {
[cleanup] Replace V8_UINT64_C macro by proper C++11 syntax V8_INT64_C will be cleaned up in a follow-up CL. R=tebbi@chromium.org,mlippautz@chromium.org Bug: v8:7109 Change-Id: I6af97e7266039eb443896b404b77b8e2b5de5adb Reviewed-on: https://chromium-review.googlesource.com/803294 Reviewed-by: Michael Lippautz <mlippautz@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#49790}
2017-12-01 08:58:16 +00:00
double expected =
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
bit_cast<double>((bit_cast<uint64_t>(i) & ~(uint64_t{0xFFFFFFFF})) |
(static_cast<uint64_t>(bit_cast<uint32_t>(j))));
CHECK_DOUBLE_EQ(expected, m.Call(i, j));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
}
}
}
TEST(RunFloat64InsertHighWord32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Uint32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float64InsertHighWord32(m.Parameter(0), m.Parameter(1)));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
FOR_FLOAT64_INPUTS(i) {
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
FOR_UINT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
uint64_t expected = (bit_cast<uint64_t>(i) & 0xFFFFFFFF) |
(static_cast<uint64_t>(j) << 32);
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_DOUBLE_EQ(bit_cast<double>(expected), m.Call(i, j));
[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble. This adds support for the double bits intrinsics to TurboFan, and is a first step towards fast Math functions inlined into TurboFan code or even compiled by themselves with TurboFan. Review URL: https://codereview.chromium.org/974313002 Cr-Commit-Position: refs/heads/master@{#27006}
2015-03-05 09:22:26 +00:00
}
}
}
[turbofan] Add new Float32Abs and Float64Abs operators. These operators compute the absolute floating point value of some arbitrary input, and are implemented without any branches (i.e. using vabs on arm, and andps/andpd on x86). R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1066393002 Cr-Commit-Position: refs/heads/master@{#27662}
2015-04-08 11:54:53 +00:00
TEST(RunFloat32Abs) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float32Abs(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(std::abs(i), m.Call(i)); }
[turbofan] Add new Float32Abs and Float64Abs operators. These operators compute the absolute floating point value of some arbitrary input, and are implemented without any branches (i.e. using vabs on arm, and andps/andpd on x86). R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1066393002 Cr-Commit-Position: refs/heads/master@{#27662}
2015-04-08 11:54:53 +00:00
}
TEST(RunFloat64Abs) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float64Abs(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(std::abs(i), m.Call(i)); }
[turbofan] Add new Float32Abs and Float64Abs operators. These operators compute the absolute floating point value of some arbitrary input, and are implemented without any branches (i.e. using vabs on arm, and andps/andpd on x86). R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1066393002 Cr-Commit-Position: refs/heads/master@{#27662}
2015-04-08 11:54:53 +00:00
}
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
TEST(RunFloat64Acos) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Acos(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::acos(i), m.Call(i)); }
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
}
TEST(RunFloat64Acosh) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Acosh(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::acosh(i), m.Call(i)); }
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
}
TEST(RunFloat64Asin) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Asin(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::asin(i), m.Call(i)); }
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
}
TEST(RunFloat64Asinh) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Asinh(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::asinh(i), m.Call(i)); }
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
}
[builtins] Introduce proper Float64Atan and Float64Atan2 operators. Import base::ieee754::atan() and base::ieee754::atan2() from fdlibm and introduce Float64Atan and Float64Atan2 TurboFan operators based on those, similar to what we already did for Float64Log and Float64Log1p. Rewrite Math.atan() and Math.atan2() as TurboFan builtin and use the operators to also inline Math.atan() and Math.atan2() into optimized TurboFan functions. R=yangguo@chromium.org BUG=v8:5086,v8:5095 Review-Url: https://codereview.chromium.org/2065503002 Cr-Commit-Position: refs/heads/master@{#36916}
2016-06-13 07:06:49 +00:00
TEST(RunFloat64Atan) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Atan(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::atan(i), m.Call(i)); }
[builtins] Introduce proper Float64Atan and Float64Atan2 operators. Import base::ieee754::atan() and base::ieee754::atan2() from fdlibm and introduce Float64Atan and Float64Atan2 TurboFan operators based on those, similar to what we already did for Float64Log and Float64Log1p. Rewrite Math.atan() and Math.atan2() as TurboFan builtin and use the operators to also inline Math.atan() and Math.atan2() into optimized TurboFan functions. R=yangguo@chromium.org BUG=v8:5086,v8:5095 Review-Url: https://codereview.chromium.org/2065503002 Cr-Commit-Position: refs/heads/master@{#36916}
2016-06-13 07:06:49 +00:00
}
[builtins] Unify Atanh, Cbrt and Expm1 as exports from flibm. BUG=v8:5103 Review-Url: https://codereview.chromium.org/2068743002 Cr-Commit-Position: refs/heads/master@{#37058}
2016-06-17 09:13:22 +00:00
TEST(RunFloat64Atanh) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Atanh(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), m.Call(1.0));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0));
CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::atanh(i), m.Call(i)); }
[builtins] Unify Atanh, Cbrt and Expm1 as exports from flibm. BUG=v8:5103 Review-Url: https://codereview.chromium.org/2068743002 Cr-Commit-Position: refs/heads/master@{#37058}
2016-06-17 09:13:22 +00:00
}
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
TEST(RunFloat64Atan2) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
MachineType::Float64());
m.Return(m.Float64Atan2(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_DOUBLE_EQ(base::ieee754::atan2(i, j), m.Call(i, j));
[builtins] Unify most of the remaining Math builtins. Import fdlibm versions of acos, acosh, asin and asinh, which are more precise and produce the same result across platforms (we were using libm versions for asin and acos so far, where both speed and precision depended on the operating system so far). Introduce appropriate TurboFan operators for these functions and use them both for inlining and for the generic builtin. Also migrate the Math.imul and Math.fround builtins to TurboFan builtins to ensure that their behavior is always exactly the same as the inlined TurboFan version (i.e. C++ truncation semantics for double to float don't necessarily meet the JavaScript semantics). For completeness, also migrate Math.sign, which can even get some nice love in TurboFan. Drive-by-fix: Some alpha-sorting on the Math related functions, and cleanup the list of Math intrinsics that we have to export via the native context currently. BUG=v8:3266,v8:3496,v8:3509,v8:3952,v8:5169,v8:5170,v8:5171,v8:5172 TBR=rossberg@chromium.org R=franzih@chromium.org Review-Url: https://codereview.chromium.org/2116753002 Cr-Commit-Position: refs/heads/master@{#37476}
2016-07-01 11:11:33 +00:00
}
}
}
[builtins] Introduce proper Float64Cos and Float64Sin. Import base::ieee754::cos() and base::ieee754::sin() from fdlibm and introduce Float64Cos and Float64Sin TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.cos() and Math.sin() as TurboFan builtins and use those operators to also inline Math.cos() and Math.sin() into optimized TurboFan functions. CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_chromium_rel_ng;tryserver.blink:linux_blink_rel R=mvstanton@chromium.org BUG=v8:5086,v8:5118 Review-Url: https://codereview.chromium.org/2073123002 Cr-Commit-Position: refs/heads/master@{#37072}
2016-06-17 15:21:48 +00:00
TEST(RunFloat64Cos) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Cos(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::cos(i), m.Call(i)); }
[builtins] Introduce proper Float64Cos and Float64Sin. Import base::ieee754::cos() and base::ieee754::sin() from fdlibm and introduce Float64Cos and Float64Sin TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.cos() and Math.sin() as TurboFan builtins and use those operators to also inline Math.cos() and Math.sin() into optimized TurboFan functions. CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_chromium_rel_ng;tryserver.blink:linux_blink_rel R=mvstanton@chromium.org BUG=v8:5086,v8:5118 Review-Url: https://codereview.chromium.org/2073123002 Cr-Commit-Position: refs/heads/master@{#37072}
2016-06-17 15:21:48 +00:00
}
[builtins] Unify Cosh, Sinh and Tanh as exports from flibm BUG=v8:5086 Review-Url: https://codereview.chromium.org/2083573002 Cr-Commit-Position: refs/heads/master@{#37424}
2016-06-30 08:41:05 +00:00
TEST(RunFloat64Cosh) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Cosh(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::cosh(i), m.Call(i)); }
[builtins] Unify Cosh, Sinh and Tanh as exports from flibm BUG=v8:5086 Review-Url: https://codereview.chromium.org/2083573002 Cr-Commit-Position: refs/heads/master@{#37424}
2016-06-30 08:41:05 +00:00
}
[builtins] Introduce proper Float64Exp operator. Import base::ieee754::exp() from FreeBSD msun and introduce a Float64Exp TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.exp() as TurboFan builtin and use that operator to also inline Math.exp() into optimized TurboFan functions. CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_chromium_rel_ng;tryserver.blink:linux_blink_rel BUG=v8:3266,v8:3468,v8:3493,v8:5086,v8:5108,chromium:620786 R=mvstanton@chromium.org Committed: https://crrev.com/93e26314afc9da9b5b8bd998688262444ed73260 Review-Url: https://codereview.chromium.org/2077533002 Cr-Original-Commit-Position: refs/heads/master@{#37037} Cr-Commit-Position: refs/heads/master@{#37047}
2016-06-17 05:19:35 +00:00
TEST(RunFloat64Exp) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Exp(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK_EQ(0.0, m.Call(-std::numeric_limits<double>::infinity()));
CHECK_DOUBLE_EQ(1.0, m.Call(-0.0));
CHECK_DOUBLE_EQ(1.0, m.Call(0.0));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::exp(i), m.Call(i)); }
[builtins] Introduce proper Float64Exp operator. Import base::ieee754::exp() from FreeBSD msun and introduce a Float64Exp TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.exp() as TurboFan builtin and use that operator to also inline Math.exp() into optimized TurboFan functions. CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_chromium_rel_ng;tryserver.blink:linux_blink_rel BUG=v8:3266,v8:3468,v8:3493,v8:5086,v8:5108,chromium:620786 R=mvstanton@chromium.org Committed: https://crrev.com/93e26314afc9da9b5b8bd998688262444ed73260 Review-Url: https://codereview.chromium.org/2077533002 Cr-Original-Commit-Position: refs/heads/master@{#37037} Cr-Commit-Position: refs/heads/master@{#37047}
2016-06-17 05:19:35 +00:00
}
[builtins] Unify Atanh, Cbrt and Expm1 as exports from flibm. BUG=v8:5103 Review-Url: https://codereview.chromium.org/2068743002 Cr-Commit-Position: refs/heads/master@{#37058}
2016-06-17 09:13:22 +00:00
TEST(RunFloat64Expm1) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Expm1(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK_EQ(-1.0, m.Call(-std::numeric_limits<double>::infinity()));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::expm1(i), m.Call(i)); }
[builtins] Unify Atanh, Cbrt and Expm1 as exports from flibm. BUG=v8:5103 Review-Url: https://codereview.chromium.org/2068743002 Cr-Commit-Position: refs/heads/master@{#37058}
2016-06-17 09:13:22 +00:00
}
[builtins] Migrate Math.log to TurboFan. Introduce a dedicated Float64Log machine operator, that is either implemented by a direct C call or by platform specific code, i.e. using the FPU on x64 and ia32. This operator is used to implement Math.log as a proper TurboFan builtin on top of the CodeStubAssembler. Also introduce a NumberLog simplified operator on top of Float64Log and use that for the fast inline path of Math.log inside TurboFan optimized code. BUG=v8:5065 Review-Url: https://codereview.chromium.org/2029413005 Cr-Commit-Position: refs/heads/master@{#36703}
2016-06-03 09:47:25 +00:00
TEST(RunFloat64Log) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Log(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
CHECK(std::isnan(m.Call(-1.0)));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::log(i), m.Call(i)); }
[builtins] Migrate Math.log to TurboFan. Introduce a dedicated Float64Log machine operator, that is either implemented by a direct C call or by platform specific code, i.e. using the FPU on x64 and ia32. This operator is used to implement Math.log as a proper TurboFan builtin on top of the CodeStubAssembler. Also introduce a NumberLog simplified operator on top of Float64Log and use that for the fast inline path of Math.log inside TurboFan optimized code. BUG=v8:5065 Review-Url: https://codereview.chromium.org/2029413005 Cr-Commit-Position: refs/heads/master@{#36703}
2016-06-03 09:47:25 +00:00
}
[turbofan] Add new Float32Abs and Float64Abs operators. These operators compute the absolute floating point value of some arbitrary input, and are implemented without any branches (i.e. using vabs on arm, and andps/andpd on x86). R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1066393002 Cr-Commit-Position: refs/heads/master@{#27662}
2015-04-08 11:54:53 +00:00
[builtins] Introduce proper Float64Log1p operator. Import base::ieee754::log1p() from fdlibm and introduce a Float64Log1p TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.log1p() as TurboFan builtin and use that operator to also inline Math.log1p() into optimized TurboFan functions. Also unify the handling of the special IEEE 754 functions somewhat in the TurboFan backends. At some point we can hopefully express this completely in the InstructionSelector (once we have an idea what to do with the ST(0) return issue on IA-32/X87). Drive-by-fix: Add some more test coverage for the log function. R=yangguo@chromium.org BUG=v8:5086,v8:5092 Review-Url: https://codereview.chromium.org/2060743002 Cr-Commit-Position: refs/heads/master@{#36914}
2016-06-13 05:46:38 +00:00
TEST(RunFloat64Log1p) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Log1p(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0));
CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::log1p(i), m.Call(i)); }
[builtins] Introduce proper Float64Log1p operator. Import base::ieee754::log1p() from fdlibm and introduce a Float64Log1p TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.log1p() as TurboFan builtin and use that operator to also inline Math.log1p() into optimized TurboFan functions. Also unify the handling of the special IEEE 754 functions somewhat in the TurboFan backends. At some point we can hopefully express this completely in the InstructionSelector (once we have an idea what to do with the ST(0) return issue on IA-32/X87). Drive-by-fix: Add some more test coverage for the log function. R=yangguo@chromium.org BUG=v8:5086,v8:5092 Review-Url: https://codereview.chromium.org/2060743002 Cr-Commit-Position: refs/heads/master@{#36914}
2016-06-13 05:46:38 +00:00
}
[builtins] Introduce proper Float64Log2 and Float64Log10 operators. BUG=v8:5095 Review-Url: https://codereview.chromium.org/2063693002 Cr-Commit-Position: refs/heads/master@{#37035}
2016-06-16 11:22:32 +00:00
TEST(RunFloat64Log2) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Log2(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
CHECK(std::isnan(m.Call(-1.0)));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::log2(i), m.Call(i)); }
[builtins] Introduce proper Float64Log2 and Float64Log10 operators. BUG=v8:5095 Review-Url: https://codereview.chromium.org/2063693002 Cr-Commit-Position: refs/heads/master@{#37035}
2016-06-16 11:22:32 +00:00
}
TEST(RunFloat64Log10) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Log10(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
CHECK(std::isnan(m.Call(-1.0)));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::log10(i), m.Call(i)); }
[builtins] Introduce proper Float64Log2 and Float64Log10 operators. BUG=v8:5095 Review-Url: https://codereview.chromium.org/2063693002 Cr-Commit-Position: refs/heads/master@{#37035}
2016-06-16 11:22:32 +00:00
}
[builtins] Unify Atanh, Cbrt and Expm1 as exports from flibm. BUG=v8:5103 Review-Url: https://codereview.chromium.org/2068743002 Cr-Commit-Position: refs/heads/master@{#37058}
2016-06-17 09:13:22 +00:00
TEST(RunFloat64Cbrt) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Cbrt(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
m.Call(std::numeric_limits<double>::infinity()));
CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(),
m.Call(-std::numeric_limits<double>::infinity()));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::cbrt(i), m.Call(i)); }
[builtins] Unify Atanh, Cbrt and Expm1 as exports from flibm. BUG=v8:5103 Review-Url: https://codereview.chromium.org/2068743002 Cr-Commit-Position: refs/heads/master@{#37058}
2016-06-17 09:13:22 +00:00
}
[builtins] Introduce proper Float64Cos and Float64Sin. Import base::ieee754::cos() and base::ieee754::sin() from fdlibm and introduce Float64Cos and Float64Sin TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.cos() and Math.sin() as TurboFan builtins and use those operators to also inline Math.cos() and Math.sin() into optimized TurboFan functions. CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_chromium_rel_ng;tryserver.blink:linux_blink_rel R=mvstanton@chromium.org BUG=v8:5086,v8:5118 Review-Url: https://codereview.chromium.org/2073123002 Cr-Commit-Position: refs/heads/master@{#37072}
2016-06-17 15:21:48 +00:00
TEST(RunFloat64Sin) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Sin(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::sin(i), m.Call(i)); }
[builtins] Introduce proper Float64Cos and Float64Sin. Import base::ieee754::cos() and base::ieee754::sin() from fdlibm and introduce Float64Cos and Float64Sin TurboFan operator based on that, similar to what we do for Float64Log. Rewrite Math.cos() and Math.sin() as TurboFan builtins and use those operators to also inline Math.cos() and Math.sin() into optimized TurboFan functions. CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_chromium_rel_ng;tryserver.blink:linux_blink_rel R=mvstanton@chromium.org BUG=v8:5086,v8:5118 Review-Url: https://codereview.chromium.org/2073123002 Cr-Commit-Position: refs/heads/master@{#37072}
2016-06-17 15:21:48 +00:00
}
[builtins] Unify Cosh, Sinh and Tanh as exports from flibm BUG=v8:5086 Review-Url: https://codereview.chromium.org/2083573002 Cr-Commit-Position: refs/heads/master@{#37424}
2016-06-30 08:41:05 +00:00
TEST(RunFloat64Sinh) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Sinh(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::sinh(i), m.Call(i)); }
[builtins] Unify Cosh, Sinh and Tanh as exports from flibm BUG=v8:5086 Review-Url: https://codereview.chromium.org/2083573002 Cr-Commit-Position: refs/heads/master@{#37424}
2016-06-30 08:41:05 +00:00
}
[builtins] Introduce proper Float64Tan operator. Import base::ieee754::tan() from fdlibm and introduce Float64Tan TurboFan operator based on that, similar to what we do for Float64Cos and Float64Sin. Rewrite Math.tan() as TurboFan builtin and use those operators to also inline Math.tan() into optimized TurboFan functions. Drive-by-fix: Kill the %_ConstructDouble intrinsics, and provide only the %ConstructDouble runtime entry for writing tests. BUG=v8:5086,v8:5126 R=yangguo@chromium.org Review-Url: https://codereview.chromium.org/2083453002 Cr-Commit-Position: refs/heads/master@{#37087}
2016-06-20 05:51:37 +00:00
TEST(RunFloat64Tan) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Tan(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::tan(i), m.Call(i)); }
[builtins] Introduce proper Float64Tan operator. Import base::ieee754::tan() from fdlibm and introduce Float64Tan TurboFan operator based on that, similar to what we do for Float64Cos and Float64Sin. Rewrite Math.tan() as TurboFan builtin and use those operators to also inline Math.tan() into optimized TurboFan functions. Drive-by-fix: Kill the %_ConstructDouble intrinsics, and provide only the %ConstructDouble runtime entry for writing tests. BUG=v8:5086,v8:5126 R=yangguo@chromium.org Review-Url: https://codereview.chromium.org/2083453002 Cr-Commit-Position: refs/heads/master@{#37087}
2016-06-20 05:51:37 +00:00
}
[builtins] Unify Cosh, Sinh and Tanh as exports from flibm BUG=v8:5086 Review-Url: https://codereview.chromium.org/2083573002 Cr-Commit-Position: refs/heads/master@{#37424}
2016-06-30 08:41:05 +00:00
TEST(RunFloat64Tanh) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Tanh(m.Parameter(0)));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(base::ieee754::tanh(i), m.Call(i)); }
[builtins] Unify Cosh, Sinh and Tanh as exports from flibm BUG=v8:5086 Review-Url: https://codereview.chromium.org/2083573002 Cr-Commit-Position: refs/heads/master@{#37424}
2016-06-30 08:41:05 +00:00
}
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
static double two_30 = 1 << 30; // 2^30 is a smi boundary.
static double two_52 = two_30 * (1 << 22); // 2^52 is a precision boundary.
static double kValues[] = {0.1,
0.2,
0.49999999999999994,
0.5,
0.7,
1.0 - std::numeric_limits<double>::epsilon(),
-0.1,
-0.49999999999999994,
-0.5,
-0.7,
1.1,
1.0 + std::numeric_limits<double>::epsilon(),
1.5,
1.7,
-1,
-1 + std::numeric_limits<double>::epsilon(),
-1 - std::numeric_limits<double>::epsilon(),
-1.1,
-1.5,
-1.7,
std::numeric_limits<double>::min(),
-std::numeric_limits<double>::min(),
std::numeric_limits<double>::max(),
-std::numeric_limits<double>::max(),
std::numeric_limits<double>::infinity(),
-std::numeric_limits<double>::infinity(),
two_30,
two_30 + 0.1,
two_30 + 0.5,
two_30 + 0.7,
two_30 - 1,
two_30 - 1 + 0.1,
two_30 - 1 + 0.5,
two_30 - 1 + 0.7,
-two_30,
-two_30 + 0.1,
-two_30 + 0.5,
-two_30 + 0.7,
-two_30 + 1,
-two_30 + 1 + 0.1,
-two_30 + 1 + 0.5,
-two_30 + 1 + 0.7,
two_52,
two_52 + 0.1,
two_52 + 0.5,
two_52 + 0.5,
two_52 + 0.7,
two_52 + 0.7,
two_52 - 1,
two_52 - 1 + 0.1,
two_52 - 1 + 0.5,
two_52 - 1 + 0.7,
-two_52,
-two_52 + 0.1,
-two_52 + 0.5,
-two_52 + 0.7,
-two_52 + 1,
-two_52 + 1 + 0.1,
-two_52 + 1 + 0.5,
-two_52 + 1 + 0.7,
two_30,
two_30 - 0.1,
two_30 - 0.5,
two_30 - 0.7,
two_30 - 1,
two_30 - 1 - 0.1,
two_30 - 1 - 0.5,
two_30 - 1 - 0.7,
-two_30,
-two_30 - 0.1,
-two_30 - 0.5,
-two_30 - 0.7,
-two_30 + 1,
-two_30 + 1 - 0.1,
-two_30 + 1 - 0.5,
-two_30 + 1 - 0.7,
two_52,
two_52 - 0.1,
two_52 - 0.5,
two_52 - 0.5,
two_52 - 0.7,
two_52 - 0.7,
two_52 - 1,
two_52 - 1 - 0.1,
two_52 - 1 - 0.5,
two_52 - 1 - 0.7,
-two_52,
-two_52 - 0.1,
-two_52 - 0.5,
-two_52 - 0.7,
-two_52 + 1,
-two_52 + 1 - 0.1,
-two_52 + 1 - 0.5,
-two_52 + 1 - 0.7};
[turbofan] Implemented the optional Float32RoundDown operator. I implemented the optional Float32RoundDown operator on x64, ia32, arm, and arm64. For arm I also had to adjust the simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1471913006 Cr-Commit-Position: refs/heads/master@{#32261}
2015-11-25 11:05:22 +00:00
TEST(RunFloat32RoundDown) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[turbofan] Implemented the optional Float32RoundDown operator. I implemented the optional Float32RoundDown operator on x64, ia32, arm, and arm64. For arm I also had to adjust the simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1471913006 Cr-Commit-Position: refs/heads/master@{#32261}
2015-11-25 11:05:22 +00:00
if (!m.machine()->Float32RoundDown().IsSupported()) return;
m.Return(m.Float32RoundDown(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(i), m.Call(i)); }
[turbofan] Implemented the optional Float32RoundDown operator. I implemented the optional Float32RoundDown operator on x64, ia32, arm, and arm64. For arm I also had to adjust the simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1471913006 Cr-Commit-Position: refs/heads/master@{#32261}
2015-11-25 11:05:22 +00:00
}
[turbofan] Unify Math.floor / Math.ceil optimization. Provide an intrinsic %MathFloor / %_MathFloor that is used to optimize both Math.ceil and Math.floor, and use the JS inlining mechanism to inline Math.ceil into TurboFan code. Although we need to touch code outside of TurboFan to make this work, this does not affect the way we handle Math.ceil and/or Math.floor in CrankShaft, because for CrankShaft the old-style builtin function id based inlining still kicks in first. Once this solution is stabilized, we can use it for Math.floor as well. And once that is settled, we can establish it as the unified way to inline builtins, and get rid of the specialized builtin function id based inlining at some point. Note that "builtin" applies to basically every piece of internal JavaScript/intrinsics based code, so this also applies to the yet to be defined JavaScript based code stubs and handlers. BUG=v8:3953 LOG=n R=yangguo@chromium.org,svenpanne@chromium.org Review URL: https://codereview.chromium.org/990963003 Cr-Commit-Position: refs/heads/master@{#27086}
2015-03-10 08:42:47 +00:00
TEST(RunFloat64RoundDown1) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Make an OptionalOperator for MachineOperatorBuilder. This makes usage of the MachineOperatorBuilder more robust, as it will be an error to request an unsupported operator. Along the way, I noticed that all 7 platforms support Float32Abs and Float64Abs. Should make them non-optional in another CL? R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1128133003 Cr-Commit-Position: refs/heads/master@{#29223}
2015-06-23 10:35:33 +00:00
if (!m.machine()->Float64RoundDown().IsSupported()) return;
Improved some tests in test-run-machops. I improved the tests for Word32Clz, Word32Ctz, and Word32Popcnt, and ported some tests to the BufferedRawMachineAssemblerTester. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1437493002 Cr-Commit-Position: refs/heads/master@{#31896}
2015-11-09 17:41:35 +00:00
m.Return(m.Float64RoundDown(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(i), m.Call(i)); }
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
}
[turbofan] Unify Math.floor / Math.ceil optimization. Provide an intrinsic %MathFloor / %_MathFloor that is used to optimize both Math.ceil and Math.floor, and use the JS inlining mechanism to inline Math.ceil into TurboFan code. Although we need to touch code outside of TurboFan to make this work, this does not affect the way we handle Math.ceil and/or Math.floor in CrankShaft, because for CrankShaft the old-style builtin function id based inlining still kicks in first. Once this solution is stabilized, we can use it for Math.floor as well. And once that is settled, we can establish it as the unified way to inline builtins, and get rid of the specialized builtin function id based inlining at some point. Note that "builtin" applies to basically every piece of internal JavaScript/intrinsics based code, so this also applies to the yet to be defined JavaScript based code stubs and handlers. BUG=v8:3953 LOG=n R=yangguo@chromium.org,svenpanne@chromium.org Review URL: https://codereview.chromium.org/990963003 Cr-Commit-Position: refs/heads/master@{#27086}
2015-03-10 08:42:47 +00:00
TEST(RunFloat64RoundDown2) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Make an OptionalOperator for MachineOperatorBuilder. This makes usage of the MachineOperatorBuilder more robust, as it will be an error to request an unsupported operator. Along the way, I noticed that all 7 platforms support Float32Abs and Float64Abs. Should make them non-optional in another CL? R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1128133003 Cr-Commit-Position: refs/heads/master@{#29223}
2015-06-23 10:35:33 +00:00
if (!m.machine()->Float64RoundDown().IsSupported()) return;
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
m.Return(m.Float64Sub(m.Float64Constant(-0.0),
m.Float64RoundDown(m.Float64Sub(m.Float64Constant(-0.0),
m.Parameter(0)))));
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
for (size_t i = 0; i < arraysize(kValues); ++i) {
[turbofan] Implemented the optional Float32RoundTruncate operator. The Float32RoundTruncate operator rounds float32 numbers towards zero. The operator is currently implemented on x64, ia32, arm, and arm64. Additionally I added support for the float32 vrintz, vrintn, and vrinta instructions to the arm simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1468303005 Cr-Commit-Position: refs/heads/master@{#32301}
2015-11-25 19:28:42 +00:00
CHECK_EQ(ceil(kValues[i]), m.Call(kValues[i]));
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
}
}
[turbofan] Implemented the optional Float32RoundUp operator. The Float32RoundUp operator rounds float32 numbers towards infinity. The operator is currently implemented on x64, ia32, arm, and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1474963002 Cr-Commit-Position: refs/heads/master@{#32262}
2015-11-25 11:07:50 +00:00
TEST(RunFloat32RoundUp) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[turbofan] Implemented the optional Float32RoundUp operator. The Float32RoundUp operator rounds float32 numbers towards infinity. The operator is currently implemented on x64, ia32, arm, and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1474963002 Cr-Commit-Position: refs/heads/master@{#32262}
2015-11-25 11:07:50 +00:00
if (!m.machine()->Float32RoundUp().IsSupported()) return;
m.Return(m.Float32RoundUp(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(i), m.Call(i)); }
[turbofan] Implemented the optional Float32RoundUp operator. The Float32RoundUp operator rounds float32 numbers towards infinity. The operator is currently implemented on x64, ia32, arm, and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1474963002 Cr-Commit-Position: refs/heads/master@{#32262}
2015-11-25 11:07:50 +00:00
}
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
TEST(RunFloat64RoundUp) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
if (!m.machine()->Float64RoundUp().IsSupported()) return;
m.Return(m.Float64RoundUp(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(i), m.Call(i)); }
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
}
[turbofan] Implemented the optional Float32RoundTiesEven operator. The Float32RoundTiesEven operator rounds float32 numbers towards the nearest integer. If the distance to two integers is the same, then the result is the even integer. This is the default rounding mode of the ieee 754 floating point standard. I implemented the optional Float32RoundTiesEven operator on x64, ia32, arm, and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1477753002 Cr-Commit-Position: refs/heads/master@{#32308}
2015-11-25 21:12:44 +00:00
TEST(RunFloat32RoundTiesEven) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[turbofan] Implemented the optional Float32RoundTiesEven operator. The Float32RoundTiesEven operator rounds float32 numbers towards the nearest integer. If the distance to two integers is the same, then the result is the even integer. This is the default rounding mode of the ieee 754 floating point standard. I implemented the optional Float32RoundTiesEven operator on x64, ia32, arm, and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1477753002 Cr-Commit-Position: refs/heads/master@{#32308}
2015-11-25 21:12:44 +00:00
if (!m.machine()->Float32RoundTiesEven().IsSupported()) return;
m.Return(m.Float32RoundTiesEven(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyint(i), m.Call(i)); }
[turbofan] Implemented the optional Float32RoundTiesEven operator. The Float32RoundTiesEven operator rounds float32 numbers towards the nearest integer. If the distance to two integers is the same, then the result is the even integer. This is the default rounding mode of the ieee 754 floating point standard. I implemented the optional Float32RoundTiesEven operator on x64, ia32, arm, and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1477753002 Cr-Commit-Position: refs/heads/master@{#32308}
2015-11-25 21:12:44 +00:00
}
[turbofan] Added the optional Float64RoundTiesEven operator to turbofan. The TiesEven rounding mode rounds float64 numbers to the nearest integer. If there are two nearest integers, then the number is rounded to the even one. This is the default rounding mode according to IEEE~754. I implemented the operator on ia32, x64, arm, arm64, mips, and mips64. I think there is a bug in the current implementation of the ppc simulator, which kept me from implementing the operator on ppc. According to my understanding of the ppc instruction manual, the FRIN instruction provides the right behavior for Float64RoundTiesEven. In the simulator, however, FRIN provides a different semantics. If there are two nearest integers, then the simulator returns the one which is further away form 0. Review URL: https://codereview.chromium.org/1440293002 Cr-Commit-Position: refs/heads/master@{#32005}
2015-11-16 11:31:18 +00:00
TEST(RunFloat64RoundTiesEven) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Added the optional Float64RoundTiesEven operator to turbofan. The TiesEven rounding mode rounds float64 numbers to the nearest integer. If there are two nearest integers, then the number is rounded to the even one. This is the default rounding mode according to IEEE~754. I implemented the operator on ia32, x64, arm, arm64, mips, and mips64. I think there is a bug in the current implementation of the ppc simulator, which kept me from implementing the operator on ppc. According to my understanding of the ppc instruction manual, the FRIN instruction provides the right behavior for Float64RoundTiesEven. In the simulator, however, FRIN provides a different semantics. If there are two nearest integers, then the simulator returns the one which is further away form 0. Review URL: https://codereview.chromium.org/1440293002 Cr-Commit-Position: refs/heads/master@{#32005}
2015-11-16 11:31:18 +00:00
if (!m.machine()->Float64RoundTiesEven().IsSupported()) return;
m.Return(m.Float64RoundTiesEven(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(i), m.Call(i)); }
[turbofan] Added the optional Float64RoundTiesEven operator to turbofan. The TiesEven rounding mode rounds float64 numbers to the nearest integer. If there are two nearest integers, then the number is rounded to the even one. This is the default rounding mode according to IEEE~754. I implemented the operator on ia32, x64, arm, arm64, mips, and mips64. I think there is a bug in the current implementation of the ppc simulator, which kept me from implementing the operator on ppc. According to my understanding of the ppc instruction manual, the FRIN instruction provides the right behavior for Float64RoundTiesEven. In the simulator, however, FRIN provides a different semantics. If there are two nearest integers, then the simulator returns the one which is further away form 0. Review URL: https://codereview.chromium.org/1440293002 Cr-Commit-Position: refs/heads/master@{#32005}
2015-11-16 11:31:18 +00:00
}
[turbofan] Implemented the optional Float32RoundTruncate operator. The Float32RoundTruncate operator rounds float32 numbers towards zero. The operator is currently implemented on x64, ia32, arm, and arm64. Additionally I added support for the float32 vrintz, vrintn, and vrinta instructions to the arm simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1468303005 Cr-Commit-Position: refs/heads/master@{#32301}
2015-11-25 19:28:42 +00:00
TEST(RunFloat32RoundTruncate) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
[turbofan] Implemented the optional Float32RoundTruncate operator. The Float32RoundTruncate operator rounds float32 numbers towards zero. The operator is currently implemented on x64, ia32, arm, and arm64. Additionally I added support for the float32 vrintz, vrintn, and vrinta instructions to the arm simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1468303005 Cr-Commit-Position: refs/heads/master@{#32301}
2015-11-25 19:28:42 +00:00
if (!m.machine()->Float32RoundTruncate().IsSupported()) return;
m.Return(m.Float32RoundTruncate(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(i), m.Call(i)); }
[turbofan] Implemented the optional Float32RoundTruncate operator. The Float32RoundTruncate operator rounds float32 numbers towards zero. The operator is currently implemented on x64, ia32, arm, and arm64. Additionally I added support for the float32 vrintz, vrintn, and vrinta instructions to the arm simulator. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1468303005 Cr-Commit-Position: refs/heads/master@{#32301}
2015-11-25 19:28:42 +00:00
}
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
TEST(RunFloat64RoundTruncate) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Make an OptionalOperator for MachineOperatorBuilder. This makes usage of the MachineOperatorBuilder more robust, as it will be an error to request an unsupported operator. Along the way, I noticed that all 7 platforms support Float32Abs and Float64Abs. Should make them non-optional in another CL? R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1128133003 Cr-Commit-Position: refs/heads/master@{#29223}
2015-06-23 10:35:33 +00:00
if (!m.machine()->Float64RoundTruncate().IsSupported()) return;
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
m.Return(m.Float64RoundTruncate(m.Parameter(0)));
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
for (size_t i = 0; i < arraysize(kValues); ++i) {
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
CHECK_EQ(trunc(kValues[i]), m.Call(kValues[i]));
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
}
}
TEST(RunFloat64RoundTiesAway) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
[turbofan] Make an OptionalOperator for MachineOperatorBuilder. This makes usage of the MachineOperatorBuilder more robust, as it will be an error to request an unsupported operator. Along the way, I noticed that all 7 platforms support Float32Abs and Float64Abs. Should make them non-optional in another CL? R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1128133003 Cr-Commit-Position: refs/heads/master@{#29223}
2015-06-23 10:35:33 +00:00
if (!m.machine()->Float64RoundTiesAway().IsSupported()) return;
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
m.Return(m.Float64RoundTiesAway(m.Parameter(0)));
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
for (size_t i = 0; i < arraysize(kValues); ++i) {
[turbofan] Added the optional Float64RoundUp operator to turbofan. I implemented it on x64, ia32, arm, arm64, mips, mips64, and ppc. Review URL: https://codereview.chromium.org/1444583002 Cr-Commit-Position: refs/heads/master@{#32004}
2015-11-16 10:37:24 +00:00
CHECK_EQ(round(kValues[i]), m.Call(kValues[i]));
Add floor, ceil, round (truncate) instructions for ia32, x64 (if SSE4.1) and add floor, ceil, round (truncate and away from zero) for arm64. R=bmeurer@chromium.org, dcarney@chromium.org, mstarzinger@chromium.org, rodolph.perfetta@arm.com TEST=test/mjsunit/asm/math-floor.js,test/mjsunit/asm/math-ceil.js,test/unittest/compiler/js-builtin-reducer-unittest.cc Review URL: https://codereview.chromium.org/677433002 Cr-Commit-Position: refs/heads/master@{#25018} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25018 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-10-30 14:15:20 +00:00
}
}
[turbofan] Fix bogus covering of Word64Equal w/ zero. Review URL: https://codereview.chromium.org/960783002 Cr-Commit-Position: refs/heads/master@{#26870}
2015-02-26 07:18:26 +00:00
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
#if !USE_SIMULATOR
namespace {
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
int32_t const kMagicFoo0 = 0xDEADBEEF;
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
int32_t foo0() { return kMagicFoo0; }
int32_t foo1(int32_t x) { return x; }
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
int32_t foo2(int32_t x, int32_t y) { return base::SubWithWraparound(x, y); }
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
uint32_t foo8(uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e,
uint32_t f, uint32_t g, uint32_t h) {
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
return a + b + c + d + e + f + g + h;
}
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
uint32_t foo9(uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e,
uint32_t f, uint32_t g, uint32_t h, uint32_t i) {
[arm64] Support passing more than eight arguments to C functions BUG=v8:6102 Review-Url: https://codereview.chromium.org/2833463002 Cr-Commit-Position: refs/heads/master@{#44765}
2017-04-21 09:30:14 +00:00
return a + b + c + d + e + f + g + h + i;
}
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
} // namespace
TEST(RunCallCFunction0) {
auto* foo0_ptr = &foo0;
RawMachineAssemblerTester<int32_t> m;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* function = m.LoadFromPointer(&foo0_ptr, MachineType::Pointer());
[turbofan] Refactor interface of calling C functions This change aims to simplify RawMachineAssembler::CallCFunction interface by use of variadic templates. Change-Id: Ie7081f692f62674f891f09abfd7149e8d95eeb81 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1526015 Commit-Queue: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#60710}
2019-03-16 19:51:22 +00:00
m.Return(m.CallCFunction(function, MachineType::Int32()));
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
CHECK_EQ(kMagicFoo0, m.Call());
}
TEST(RunCallCFunction1) {
auto* foo1_ptr = &foo1;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Node* function = m.LoadFromPointer(&foo1_ptr, MachineType::Pointer());
[turbofan] Refactor interface of calling C functions This change aims to simplify RawMachineAssembler::CallCFunction interface by use of variadic templates. Change-Id: Ie7081f692f62674f891f09abfd7149e8d95eeb81 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1526015 Commit-Queue: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#60710}
2019-03-16 19:51:22 +00:00
m.Return(
m.CallCFunction(function, MachineType::Int32(),
std::make_pair(MachineType::Int32(), m.Parameter(0))));
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t const expected = i;
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
CHECK_EQ(expected, m.Call(expected));
}
}
TEST(RunCallCFunction2) {
auto* foo2_ptr = &foo2;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
MachineType::Int32());
Node* function = m.LoadFromPointer(&foo2_ptr, MachineType::Pointer());
[turbofan] Refactor interface of calling C functions This change aims to simplify RawMachineAssembler::CallCFunction interface by use of variadic templates. Change-Id: Ie7081f692f62674f891f09abfd7149e8d95eeb81 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1526015 Commit-Queue: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#60710}
2019-03-16 19:51:22 +00:00
m.Return(
m.CallCFunction(function, MachineType::Int32(),
std::make_pair(MachineType::Int32(), m.Parameter(0)),
std::make_pair(MachineType::Int32(), m.Parameter(1))));
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t const x = i;
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
FOR_INT32_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t const y = j;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
CHECK_EQ(base::SubWithWraparound(x, y), m.Call(x, y));
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
}
}
}
TEST(RunCallCFunction8) {
auto* foo8_ptr = &foo8;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Node* function = m.LoadFromPointer(&foo8_ptr, MachineType::Pointer());
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
Node* param = m.Parameter(0);
[turbofan] Refactor interface of calling C functions This change aims to simplify RawMachineAssembler::CallCFunction interface by use of variadic templates. Change-Id: Ie7081f692f62674f891f09abfd7149e8d95eeb81 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1526015 Commit-Queue: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#60710}
2019-03-16 19:51:22 +00:00
m.Return(m.CallCFunction(function, MachineType::Int32(),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(), param)));
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t const x = i;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
CHECK_EQ(base::MulWithWraparound(x, 8), m.Call(x));
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
}
}
[arm64] Support passing more than eight arguments to C functions BUG=v8:6102 Review-Url: https://codereview.chromium.org/2833463002 Cr-Commit-Position: refs/heads/master@{#44765}
2017-04-21 09:30:14 +00:00
TEST(RunCallCFunction9) {
auto* foo9_ptr = &foo9;
RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
Node* function = m.LoadFromPointer(&foo9_ptr, MachineType::Pointer());
Node* param = m.Parameter(0);
[turbofan] Refactor interface of calling C functions This change aims to simplify RawMachineAssembler::CallCFunction interface by use of variadic templates. Change-Id: Ie7081f692f62674f891f09abfd7149e8d95eeb81 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1526015 Commit-Queue: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#60710}
2019-03-16 19:51:22 +00:00
m.Return(
m.CallCFunction(function, MachineType::Int32(),
std::make_pair(MachineType::Int32(), param),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(1))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(2))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(3))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(4))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(5))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(6))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(7))),
std::make_pair(MachineType::Int32(),
m.Int32Add(param, m.Int32Constant(8)))));
[arm64] Support passing more than eight arguments to C functions BUG=v8:6102 Review-Url: https://codereview.chromium.org/2833463002 Cr-Commit-Position: refs/heads/master@{#44765}
2017-04-21 09:30:14 +00:00
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
int32_t const x = i;
[ubsan] Fix numerical overflows in the compiler Mostly signed integer overflows, and a few cases of double division by zero (which is defined by IEEE-754 to return Infinity (or NaN for 0/0) but is UB in C++). Bug: v8:3770 Change-Id: I8007987594ff534ca697c1c3247215a72a001343 Reviewed-on: https://chromium-review.googlesource.com/c/1403132 Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Cr-Commit-Position: refs/heads/master@{#58693}
2019-01-10 10:38:25 +00:00
CHECK_EQ(base::AddWithWraparound(base::MulWithWraparound(x, 9), 36),
m.Call(x));
[arm64] Support passing more than eight arguments to C functions BUG=v8:6102 Review-Url: https://codereview.chromium.org/2833463002 Cr-Commit-Position: refs/heads/master@{#44765}
2017-04-21 09:30:14 +00:00
}
}
[turbofan] Add basic support for calling to (a subset of) C functions. This introduces some initial building blocks for calling out to C/C++ functions directly from TurboFan generated code objects. R=svenpanne@chromium.org Review URL: https://codereview.chromium.org/1205023002. Cr-Commit-Position: refs/heads/master@{#29279}
2015-06-25 08:32:06 +00:00
#endif // USE_SIMULATOR
[turbofan] support for Int64 in CheckedLoad/CheckedStore on 64-bit platforms. This is to support WebAssembly 64-bit ints in the short term, since it currently uses CheckedLoad/CheckedStore for accesses to the memory. In the long run, we'll change this to be explicit bounds checks that throw on out of bounds. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/1310323006 Cr-Commit-Position: refs/heads/master@{#30555}
2015-09-03 10:45:35 +00:00
#if V8_TARGET_ARCH_64_BIT
[test] Add FOR_INT64_INPUTS and FOR_UINT64_INPUTS. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/1360133002 Cr-Commit-Position: refs/heads/master@{#30884}
2015-09-23 11:04:44 +00:00
// TODO(titzer): run int64 tests on all platforms when supported.
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
[turbofan] Initial Word64 support in representation selection. This adds support to TurboFan's representation selection for the Word64 representation, and makes use of that to handle indices for memory access and allocation instructions (i.e. LoadElement, StoreElement, Allocate, etc.). These instructions had previously used Word32 as representation for the indices / sizes, and then internally converted it to the correct representation (aka Word64 on 64-bit architectures) later on, but that was kind of brittle, and sometimes led to weird generated code. The change thus only adds support to convert integer values in the safe integer range from all kinds of representations to Word64 (on 64-bit architectures). We don't yet handle the opposite direction and none of the representation selection heuristics for the numeric operations were changed so far. This will be done in follow-up CLs. This CL itself is supposed to be neutral wrt. functionality, and only serves as a starting point, and a cleanup for the (weird) implicit Word64 index/size handling. Bug: v8:7881, v8:8015, v8:8171 Design-Document: http://bit.ly/turbofan-word64 Change-Id: I3c6961a0e96cbc3fb8ac9d3e1be8f2e5c89bfd25 Cq-Include-Trybots: luci.chromium.try:linux_chromium_headless_rel Reviewed-on: https://chromium-review.googlesource.com/1224932 Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Cr-Commit-Position: refs/heads/master@{#55886}
2018-09-14 07:32:02 +00:00
TEST(RunChangeFloat64ToInt64) {
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
m.Return(m.ChangeFloat64ToInt64(m.Parameter(0)));
FOR_INT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
double input = static_cast<double>(i);
if (static_cast<int64_t>(input) == i) {
[turbofan] Initial Word64 support in representation selection. This adds support to TurboFan's representation selection for the Word64 representation, and makes use of that to handle indices for memory access and allocation instructions (i.e. LoadElement, StoreElement, Allocate, etc.). These instructions had previously used Word32 as representation for the indices / sizes, and then internally converted it to the correct representation (aka Word64 on 64-bit architectures) later on, but that was kind of brittle, and sometimes led to weird generated code. The change thus only adds support to convert integer values in the safe integer range from all kinds of representations to Word64 (on 64-bit architectures). We don't yet handle the opposite direction and none of the representation selection heuristics for the numeric operations were changed so far. This will be done in follow-up CLs. This CL itself is supposed to be neutral wrt. functionality, and only serves as a starting point, and a cleanup for the (weird) implicit Word64 index/size handling. Bug: v8:7881, v8:8015, v8:8171 Design-Document: http://bit.ly/turbofan-word64 Change-Id: I3c6961a0e96cbc3fb8ac9d3e1be8f2e5c89bfd25 Cq-Include-Trybots: luci.chromium.try:linux_chromium_headless_rel Reviewed-on: https://chromium-review.googlesource.com/1224932 Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Cr-Commit-Position: refs/heads/master@{#55886}
2018-09-14 07:32:02 +00:00
CHECK_EQ(static_cast<int64_t>(input), m.Call(input));
}
}
}
[turbofan] Initial support to compute NumberAdd/NumberSubtract in Word64. This change introduces the necessary conversion operators to convert from Word64 to other representations (Tagged, Word32, Float64, etc.), and plugs in the Word64 representation for NumberAdd/NumberSubtract, such that TurboFan will go to Int64Add/Sub on 64-bit architectures when the inputs and the output of the operation is in safe integer range. This includes the necessary changes to the Deoptimizer to be able to rematerialize Int64 values as Smi/HeapNumber when going back to Ignition later. This change might affect performance, although measurements indicate that there should be no noticable performance impact. The goal is to have TurboFan support Word64 representation to a degree that changing the TypedArray length to an uint64_t (for 64-bit archs) becomes viable and doesn't have any negative performance implications. Independent of that we might get performance improvements in other areas such as for crypto code later. Bug: v8:4153, v8:7881, v8:8171, v8:8178 Design-Document: bit.ly/turbofan-word64 Change-Id: I29d56e2a31c1bae61d04a89d29ea73f21fd49c59 Cq-Include-Trybots: luci.chromium.try:linux_chromium_headless_rel Reviewed-on: https://chromium-review.googlesource.com/1225709 Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Cr-Commit-Position: refs/heads/master@{#55937}
2018-09-14 15:28:42 +00:00
TEST(RunChangeInt64ToFloat64) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Int64());
m.Return(m.ChangeInt64ToFloat64(m.Parameter(0)));
FOR_INT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
double output = static_cast<double>(i);
if (static_cast<int64_t>(output) == i) {
CHECK_EQ(output, m.Call(i));
[turbofan] Initial support to compute NumberAdd/NumberSubtract in Word64. This change introduces the necessary conversion operators to convert from Word64 to other representations (Tagged, Word32, Float64, etc.), and plugs in the Word64 representation for NumberAdd/NumberSubtract, such that TurboFan will go to Int64Add/Sub on 64-bit architectures when the inputs and the output of the operation is in safe integer range. This includes the necessary changes to the Deoptimizer to be able to rematerialize Int64 values as Smi/HeapNumber when going back to Ignition later. This change might affect performance, although measurements indicate that there should be no noticable performance impact. The goal is to have TurboFan support Word64 representation to a degree that changing the TypedArray length to an uint64_t (for 64-bit archs) becomes viable and doesn't have any negative performance implications. Independent of that we might get performance improvements in other areas such as for crypto code later. Bug: v8:4153, v8:7881, v8:8171, v8:8178 Design-Document: bit.ly/turbofan-word64 Change-Id: I29d56e2a31c1bae61d04a89d29ea73f21fd49c59 Cq-Include-Trybots: luci.chromium.try:linux_chromium_headless_rel Reviewed-on: https://chromium-review.googlesource.com/1225709 Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org> Cr-Commit-Position: refs/heads/master@{#55937}
2018-09-14 15:28:42 +00:00
}
}
}
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
TEST(RunBitcastInt64ToFloat64) {
int64_t input = 1;
Reland "[test] Add nan bit patterns to uint{32,64}_vector" This is a reland of 6f93d59d9204101ee11c3ed9513c7012b0f75169. One more test had to be disabled (tracked by bug 6954), and two machops tests needed to be changed to use boxed floats and doubles. Original change's description: > [test] Add nan bit patterns to uint{32,64}_vector > > If you just cast those patterns to float or double and pass them > around, the quiet/signaling NaN bit might change. We had several bugs > around this, so add these patterns to the general input vectors. > > This uncovers a bug in the wasm interpreter, which will be fixed in a > separate CL. > > R=ahaas@chromium.org > > Bug: v8:6947, v8:6954 > Change-Id: I205b8ab784b087b1e4988190fa725df0b90e7ee0 > Reviewed-on: https://chromium-review.googlesource.com/725345 > Commit-Queue: Clemens Hammacher <clemensh@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#48731} Bug: v8:6947, v8:6954 Change-Id: I9a38b5d9324131c3950c537910371a73c93d2c13 Reviewed-on: https://chromium-review.googlesource.com/728439 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#48780}
2017-10-20 09:12:46 +00:00
Float64 output;
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
RawMachineAssemblerTester<int32_t> m;
m.StoreToPointer(
Reland "[test] Add nan bit patterns to uint{32,64}_vector" This is a reland of 6f93d59d9204101ee11c3ed9513c7012b0f75169. One more test had to be disabled (tracked by bug 6954), and two machops tests needed to be changed to use boxed floats and doubles. Original change's description: > [test] Add nan bit patterns to uint{32,64}_vector > > If you just cast those patterns to float or double and pass them > around, the quiet/signaling NaN bit might change. We had several bugs > around this, so add these patterns to the general input vectors. > > This uncovers a bug in the wasm interpreter, which will be fixed in a > separate CL. > > R=ahaas@chromium.org > > Bug: v8:6947, v8:6954 > Change-Id: I205b8ab784b087b1e4988190fa725df0b90e7ee0 > Reviewed-on: https://chromium-review.googlesource.com/725345 > Commit-Queue: Clemens Hammacher <clemensh@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#48731} Bug: v8:6947, v8:6954 Change-Id: I9a38b5d9324131c3950c537910371a73c93d2c13 Reviewed-on: https://chromium-review.googlesource.com/728439 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#48780}
2017-10-20 09:12:46 +00:00
output.get_bits_address(), MachineRepresentation::kFloat64,
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.BitcastInt64ToFloat64(m.LoadFromPointer(&input, MachineType::Int64())));
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
m.Return(m.Int32Constant(11));
[test] Add FOR_INT64_INPUTS and FOR_UINT64_INPUTS. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/1360133002 Cr-Commit-Position: refs/heads/master@{#30884}
2015-09-23 11:04:44 +00:00
FOR_INT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
input = i;
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
CHECK_EQ(11, m.Call());
Reland "[test] Add nan bit patterns to uint{32,64}_vector" This is a reland of 6f93d59d9204101ee11c3ed9513c7012b0f75169. One more test had to be disabled (tracked by bug 6954), and two machops tests needed to be changed to use boxed floats and doubles. Original change's description: > [test] Add nan bit patterns to uint{32,64}_vector > > If you just cast those patterns to float or double and pass them > around, the quiet/signaling NaN bit might change. We had several bugs > around this, so add these patterns to the general input vectors. > > This uncovers a bug in the wasm interpreter, which will be fixed in a > separate CL. > > R=ahaas@chromium.org > > Bug: v8:6947, v8:6954 > Change-Id: I205b8ab784b087b1e4988190fa725df0b90e7ee0 > Reviewed-on: https://chromium-review.googlesource.com/725345 > Commit-Queue: Clemens Hammacher <clemensh@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#48731} Bug: v8:6947, v8:6954 Change-Id: I9a38b5d9324131c3950c537910371a73c93d2c13 Reviewed-on: https://chromium-review.googlesource.com/728439 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#48780}
2017-10-20 09:12:46 +00:00
Float64 expected = Float64::FromBits(input);
CHECK_EQ(expected.get_bits(), output.get_bits());
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
}
}
TEST(RunBitcastFloat64ToInt64) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
[turbofan] Implemented the ChangeFloat64ToInt64 TurboFan operator. The ChangeFloat64ToInt64 operator changes the representation of a float64 input value to int64 if the input value can be represented exactly on int64. Otherwise the result is currently undefined. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1455983002 Cr-Commit-Position: refs/heads/master@{#32102}
2015-11-19 08:26:40 +00:00
m.Return(m.BitcastFloat64ToInt64(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_FLOAT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(i), m.Call(i)); }
[turbofan] Implemented the ChangeFloat64ToInt64 TurboFan operator. The ChangeFloat64ToInt64 operator changes the representation of a float64 input value to int64 if the input value can be represented exactly on int64. Otherwise the result is currently undefined. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1455983002 Cr-Commit-Position: refs/heads/master@{#32102}
2015-11-19 08:26:40 +00:00
}
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
TEST(RunTryTruncateFloat32ToInt64WithoutCheck) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float32());
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
m.Return(m.TryTruncateFloat32ToInt64(m.Parameter(0)));
[turbofan] Implemented the TruncateFloat32ToInt64 TurboFan operator. The TruncateFloat32ToInt64 operator converts a float32 to an int64 using the round-to-zero rounding mode (truncate). If the input value is outside the int64 range, then the result depends on the architecture. I implemented the operator on x64, arm64, and mips64. R=titzer@chromium.org, jacob.bramley@arm.com Committed: https://crrev.com/1df1066c3c77464d2a68d7c8d501a5a0f3ad195a Cr-Commit-Position: refs/heads/master@{#32315} Review URL: https://codereview.chromium.org/1476063002 Cr-Commit-Position: refs/heads/master@{#32325}
2015-11-26 10:28:21 +00:00
FOR_INT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
float input = static_cast<float>(i);
[turbofan] Fixed a bug in TryTruncateFloatXXToInt64 with INT64_MIN. On x64 and arm64 TryTruncateFloatXXToInt64 incorrectly failed when the input was INT64_MIN. R=bradnelson@chromium.org, mstarzinger@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1526293002 Cr-Commit-Position: refs/heads/master@{#32908}
2015-12-16 15:34:24 +00:00
if (input < static_cast<float>(INT64_MAX) &&
input >= static_cast<float>(INT64_MIN)) {
[turbofan] Implemented the TruncateFloat32ToInt64 TurboFan operator. The TruncateFloat32ToInt64 operator converts a float32 to an int64 using the round-to-zero rounding mode (truncate). If the input value is outside the int64 range, then the result depends on the architecture. I implemented the operator on x64, arm64, and mips64. R=titzer@chromium.org, jacob.bramley@arm.com Committed: https://crrev.com/1df1066c3c77464d2a68d7c8d501a5a0f3ad195a Cr-Commit-Position: refs/heads/master@{#32315} Review URL: https://codereview.chromium.org/1476063002 Cr-Commit-Position: refs/heads/master@{#32325}
2015-11-26 10:28:21 +00:00
CHECK_EQ(static_cast<int64_t>(input), m.Call(input));
}
}
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
}
TEST(RunTryTruncateFloat32ToInt64WithCheck) {
int64_t success = 0;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float32());
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
Node* trunc = m.TryTruncateFloat32ToInt64(m.Parameter(0));
Node* val = m.Projection(0, trunc);
Node* check = m.Projection(1, trunc);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&success, MachineRepresentation::kWord64, check);
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
m.Return(val);
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (i < static_cast<float>(INT64_MAX) &&
i >= static_cast<float>(INT64_MIN)) {
CHECK_EQ(static_cast<int64_t>(i), m.Call(i));
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
CHECK_NE(0, success);
} else {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i);
[turbofan] Change TruncateFloat32ToInt64 to TryTruncateFloat32ToInt64. This operator now provides a second output which indicates whether the conversion from float32 to int64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1504363002 Cr-Commit-Position: refs/heads/master@{#32737}
2015-12-10 08:12:14 +00:00
CHECK_EQ(0, success);
[turbofan] Implemented the TruncateFloat32ToInt64 TurboFan operator. The TruncateFloat32ToInt64 operator converts a float32 to an int64 using the round-to-zero rounding mode (truncate). If the input value is outside the int64 range, then the result depends on the architecture. I implemented the operator on x64, arm64, and mips64. R=titzer@chromium.org, jacob.bramley@arm.com Committed: https://crrev.com/1df1066c3c77464d2a68d7c8d501a5a0f3ad195a Cr-Commit-Position: refs/heads/master@{#32315} Review URL: https://codereview.chromium.org/1476063002 Cr-Commit-Position: refs/heads/master@{#32325}
2015-11-26 10:28:21 +00:00
}
}
}
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
TEST(RunTryTruncateFloat64ToInt64WithoutCheck) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
m.Return(m.TryTruncateFloat64ToInt64(m.Parameter(0)));
[turbofan] Implemented the ChangeFloat64ToInt64 TurboFan operator. The ChangeFloat64ToInt64 operator changes the representation of a float64 input value to int64 if the input value can be represented exactly on int64. Otherwise the result is currently undefined. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1455983002 Cr-Commit-Position: refs/heads/master@{#32102}
2015-11-19 08:26:40 +00:00
FOR_INT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
double input = static_cast<double>(i);
[turbofan] Implemented the ChangeFloat64ToInt64 TurboFan operator. The ChangeFloat64ToInt64 operator changes the representation of a float64 input value to int64 if the input value can be represented exactly on int64. Otherwise the result is currently undefined. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1455983002 Cr-Commit-Position: refs/heads/master@{#32102}
2015-11-19 08:26:40 +00:00
CHECK_EQ(static_cast<int64_t>(input), m.Call(input));
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
}
}
[turbofan] Added the RoundInt64ToFloat64 instruction to TurboFan. Review URL: https://codereview.chromium.org/1424333002 Cr-Commit-Position: refs/heads/master@{#31752}
2015-11-03 15:46:00 +00:00
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
TEST(RunTryTruncateFloat64ToInt64WithCheck) {
int64_t success = 0;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
Node* trunc = m.TryTruncateFloat64ToInt64(m.Parameter(0));
Node* val = m.Projection(0, trunc);
Node* check = m.Projection(1, trunc);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&success, MachineRepresentation::kWord64, check);
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
m.Return(val);
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (i < static_cast<double>(INT64_MAX) &&
i >= static_cast<double>(INT64_MIN)) {
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
// Conversions within this range should succeed.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_EQ(static_cast<int64_t>(i), m.Call(i));
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
CHECK_NE(0, success);
} else {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i);
[turbofan] Changed TruncateFloat64ToInt64 to TryTruncateFloat64ToInt64. The new operator provides a second output which indicates whether the conversion from float64 to int64 was successful or not. The second output returns 0 if the conversion fails. If the conversion succeeds, then the second output is differs from 0. The second output can be ignored, which means that the operator can be used the same way as the original operator. I implemented the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1495213003 Cr-Commit-Position: refs/heads/master@{#32653}
2015-12-07 12:12:19 +00:00
CHECK_EQ(0, success);
}
}
}
[turbofan] Fixed the second return value of TryTruncateFloatXXToUint64. As required by the spec, the second return value now returns success also for the range between 0 and -1 where the conversion results in 0. R=bradnelson@chromium.org, mstarzinger@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1533503002 Cr-Commit-Position: refs/heads/master@{#32936}
2015-12-17 10:24:36 +00:00
TEST(RunTryTruncateFloat32ToUint64WithoutCheck) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32());
[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64. TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it provides an optional second return value which indicates whether the conversion succeeded (i.e. float32 value was within uint64 range) or not. I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? Additionally I fixed a bug on x64 and mips64 in the implementation of TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0 were handled incorrectly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1512023002 Cr-Commit-Position: refs/heads/master@{#32796}
2015-12-11 14:06:59 +00:00
m.Return(m.TryTruncateFloat32ToUint64(m.Parameter(0)));
[turbofan] Implemented the TruncateFloat32ToUint64 TurboFan operator. The TruncateFloat32ToUint64 operator converts a float32 to an uint64 using round-to-zero rounding mode. If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1479713003 Cr-Commit-Position: refs/heads/master@{#32379}
2015-11-27 15:01:34 +00:00
FOR_UINT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
float input = static_cast<float>(i);
[turbofan] Fixed the second return value of TryTruncateFloatXXToUint64. As required by the spec, the second return value now returns success also for the range between 0 and -1 where the conversion results in 0. R=bradnelson@chromium.org, mstarzinger@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1533503002 Cr-Commit-Position: refs/heads/master@{#32936}
2015-12-17 10:24:36 +00:00
// This condition on 'input' is required because
// static_cast<float>(UINT64_MAX) results in a value outside uint64 range.
if (input < static_cast<float>(UINT64_MAX)) {
[turbofan] Implemented the TruncateFloat32ToUint64 TurboFan operator. The TruncateFloat32ToUint64 operator converts a float32 to an uint64 using round-to-zero rounding mode. If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1479713003 Cr-Commit-Position: refs/heads/master@{#32379}
2015-11-27 15:01:34 +00:00
CHECK_EQ(static_cast<uint64_t>(input), m.Call(input));
}
}
}
[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64. TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it provides an optional second return value which indicates whether the conversion succeeded (i.e. float32 value was within uint64 range) or not. I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? Additionally I fixed a bug on x64 and mips64 in the implementation of TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0 were handled incorrectly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1512023002 Cr-Commit-Position: refs/heads/master@{#32796}
2015-12-11 14:06:59 +00:00
TEST(RunTryTruncateFloat32ToUint64WithCheck) {
int64_t success = 0;
BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32());
Node* trunc = m.TryTruncateFloat32ToUint64(m.Parameter(0));
Node* val = m.Projection(0, trunc);
Node* check = m.Projection(1, trunc);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&success, MachineRepresentation::kWord64, check);
[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64. TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it provides an optional second return value which indicates whether the conversion succeeded (i.e. float32 value was within uint64 range) or not. I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? Additionally I fixed a bug on x64 and mips64 in the implementation of TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0 were handled incorrectly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1512023002 Cr-Commit-Position: refs/heads/master@{#32796}
2015-12-11 14:06:59 +00:00
m.Return(val);
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (i < static_cast<float>(UINT64_MAX) && i > -1.0) {
[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64. TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it provides an optional second return value which indicates whether the conversion succeeded (i.e. float32 value was within uint64 range) or not. I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? Additionally I fixed a bug on x64 and mips64 in the implementation of TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0 were handled incorrectly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1512023002 Cr-Commit-Position: refs/heads/master@{#32796}
2015-12-11 14:06:59 +00:00
// Conversions within this range should succeed.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_EQ(static_cast<uint64_t>(i), m.Call(i));
[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64. TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it provides an optional second return value which indicates whether the conversion succeeded (i.e. float32 value was within uint64 range) or not. I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? Additionally I fixed a bug on x64 and mips64 in the implementation of TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0 were handled incorrectly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1512023002 Cr-Commit-Position: refs/heads/master@{#32796}
2015-12-11 14:06:59 +00:00
CHECK_NE(0, success);
} else {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i);
[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64. TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it provides an optional second return value which indicates whether the conversion succeeded (i.e. float32 value was within uint64 range) or not. I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you please take care of the ppc64 implementation of the second output? Additionally I fixed a bug on x64 and mips64 in the implementation of TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0 were handled incorrectly. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1512023002 Cr-Commit-Position: refs/heads/master@{#32796}
2015-12-11 14:06:59 +00:00
CHECK_EQ(0, success);
}
}
}
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
TEST(RunTryTruncateFloat64ToUint64WithoutCheck) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float64());
[wasm] Removed dead code. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1760613002 Cr-Commit-Position: refs/heads/master@{#34442}
2016-03-02 17:59:31 +00:00
m.Return(m.TryTruncateFloat64ToUint64(m.Parameter(0)));
[turbofan] Implemented the TruncateFloat64ToUint64 TurboFan operator. The TruncateFloat64ToUint64 operator converts a float64 to an uint64 using round-to-zero rounding mode (truncate). If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. @v8-ppc-ports and @v8-mips-ports, can you do the implementations for ppc64 and mips64? R=titzer@chromium.org Review URL: https://codereview.chromium.org/1457373002 Cr-Commit-Position: refs/heads/master@{#32127}
2015-11-19 20:42:03 +00:00
FOR_UINT64_INPUTS(j) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
double input = static_cast<double>(j);
[turbofan] Implemented the TruncateFloat64ToUint64 TurboFan operator. The TruncateFloat64ToUint64 operator converts a float64 to an uint64 using round-to-zero rounding mode (truncate). If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. @v8-ppc-ports and @v8-mips-ports, can you do the implementations for ppc64 and mips64? R=titzer@chromium.org Review URL: https://codereview.chromium.org/1457373002 Cr-Commit-Position: refs/heads/master@{#32127}
2015-11-19 20:42:03 +00:00
[turbofan] Fixed the second return value of TryTruncateFloatXXToUint64. As required by the spec, the second return value now returns success also for the range between 0 and -1 where the conversion results in 0. R=bradnelson@chromium.org, mstarzinger@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com Review URL: https://codereview.chromium.org/1533503002 Cr-Commit-Position: refs/heads/master@{#32936}
2015-12-17 10:24:36 +00:00
if (input < static_cast<float>(UINT64_MAX)) {
[turbofan] Implemented the TruncateFloat64ToUint64 TurboFan operator. The TruncateFloat64ToUint64 operator converts a float64 to an uint64 using round-to-zero rounding mode (truncate). If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. @v8-ppc-ports and @v8-mips-ports, can you do the implementations for ppc64 and mips64? R=titzer@chromium.org Review URL: https://codereview.chromium.org/1457373002 Cr-Commit-Position: refs/heads/master@{#32127}
2015-11-19 20:42:03 +00:00
CHECK_EQ(static_cast<uint64_t>(input), m.Call(input));
}
}
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
}
TEST(RunTryTruncateFloat64ToUint64WithCheck) {
int64_t success = 0;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
Node* trunc = m.TryTruncateFloat64ToUint64(m.Parameter(0));
Node* val = m.Projection(0, trunc);
Node* check = m.Projection(1, trunc);
[turbofan] Store nodes use only MachineRepresentation, not MachineType. Review URL: https://codereview.chromium.org/1513383003 Cr-Commit-Position: refs/heads/master@{#32803}
2015-12-11 15:34:00 +00:00
m.StoreToPointer(&success, MachineRepresentation::kWord64, check);
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
m.Return(val);
[turbofan] Implemented the TruncateFloat64ToUint64 TurboFan operator. The TruncateFloat64ToUint64 operator converts a float64 to an uint64 using round-to-zero rounding mode (truncate). If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. @v8-ppc-ports and @v8-mips-ports, can you do the implementations for ppc64 and mips64? R=titzer@chromium.org Review URL: https://codereview.chromium.org/1457373002 Cr-Commit-Position: refs/heads/master@{#32127}
2015-11-19 20:42:03 +00:00
FOR_FLOAT64_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
if (i < 18446744073709551616.0 && i > -1) {
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
// Conversions within this range should succeed.
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
CHECK_EQ(static_cast<uint64_t>(i), static_cast<uint64_t>(m.Call(i)));
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
CHECK_NE(0, success);
} else {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
m.Call(i);
[turbofan] Change TruncateFloat64ToUint64 to TryTruncateFloatToUint64. This operator now provides a second output which indicates whether the conversion from float64 to uint64 was successful or not. The second output returns 0 if the conversion fails, or something else if the conversion succeeds. The second output can be ignored, which means that the operator can be used the same as the original operator. I implement the new operator on x64 and arm64. @v8-mips-ports and @v8-ppc-ports, can you please take care of the mips64 and ppc64 implementation of the second output? R=titzer@chromium.org, v8-arm-ports@googlegroups.com Review URL: https://codereview.chromium.org/1507703002 Cr-Commit-Position: refs/heads/master@{#32705}
2015-12-09 11:15:18 +00:00
CHECK_EQ(0, success);
[turbofan] Implemented the TruncateFloat64ToUint64 TurboFan operator. The TruncateFloat64ToUint64 operator converts a float64 to an uint64 using round-to-zero rounding mode (truncate). If the input value is outside uint64 range, then the result depends on the architecture. I provide an implementation for x64 and arm64. @v8-ppc-ports and @v8-mips-ports, can you do the implementations for ppc64 and mips64? R=titzer@chromium.org Review URL: https://codereview.chromium.org/1457373002 Cr-Commit-Position: refs/heads/master@{#32127}
2015-11-19 20:42:03 +00:00
}
}
}
Implemented the RoundInt64ToFloat32 TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1435603003 Cr-Commit-Position: refs/heads/master@{#31929}
2015-11-10 20:39:18 +00:00
TEST(RunRoundInt64ToFloat32) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Int64());
Implemented the RoundInt64ToFloat32 TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1435603003 Cr-Commit-Position: refs/heads/master@{#31929}
2015-11-10 20:39:18 +00:00
m.Return(m.RoundInt64ToFloat32(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<float>(i), m.Call(i)); }
Implemented the RoundInt64ToFloat32 TurboFan operator for x64, arm64, and mips64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1435603003 Cr-Commit-Position: refs/heads/master@{#31929}
2015-11-10 20:39:18 +00:00
}
[turbofan] Added the RoundInt64ToFloat64 instruction to TurboFan. Review URL: https://codereview.chromium.org/1424333002 Cr-Commit-Position: refs/heads/master@{#31752}
2015-11-03 15:46:00 +00:00
TEST(RunRoundInt64ToFloat64) {
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Int64());
[turbofan] Added the RoundInt64ToFloat64 instruction to TurboFan. Review URL: https://codereview.chromium.org/1424333002 Cr-Commit-Position: refs/heads/master@{#31752}
2015-11-03 15:46:00 +00:00
m.Return(m.RoundInt64ToFloat64(m.Parameter(0)));
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<double>(i), m.Call(i)); }
[turbofan] Added the RoundInt64ToFloat64 instruction to TurboFan. Review URL: https://codereview.chromium.org/1424333002 Cr-Commit-Position: refs/heads/master@{#31752}
2015-11-03 15:46:00 +00:00
}
Implemented the RoundUint64ToFloat64 TurboFan operator for x64 and arm64. I don't see obvious implementations for mips64 and ppc64, so I would need help for these two platforms. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1436943002 Cr-Commit-Position: refs/heads/master@{#31946}
2015-11-11 19:12:25 +00:00
TEST(RunRoundUint64ToFloat64) {
[tests] Cleanup of the RunRoundUint64ToFloat64 test. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1450353002 Cr-Commit-Position: refs/heads/master@{#32036}
2015-11-17 13:07:14 +00:00
struct {
uint64_t input;
uint64_t expected;
} values[] = {{0x0, 0x0},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x1, 0x3FF0000000000000},
{0xFFFFFFFF, 0x41EFFFFFFFE00000},
{0x1B09788B, 0x41BB09788B000000},
{0x4C5FCE8, 0x419317F3A0000000},
{0xCC0DE5BF, 0x41E981BCB7E00000},
[tests] Cleanup of the RunRoundUint64ToFloat64 test. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1450353002 Cr-Commit-Position: refs/heads/master@{#32036}
2015-11-17 13:07:14 +00:00
{0x2, 0x4000000000000000},
{0x3, 0x4008000000000000},
{0x4, 0x4010000000000000},
{0x5, 0x4014000000000000},
{0x8, 0x4020000000000000},
{0x9, 0x4022000000000000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0xFFFFFFFFFFFFFFFF, 0x43F0000000000000},
{0xFFFFFFFFFFFFFFFE, 0x43F0000000000000},
{0xFFFFFFFFFFFFFFFD, 0x43F0000000000000},
{0x100000000, 0x41F0000000000000},
{0xFFFFFFFF00000000, 0x43EFFFFFFFE00000},
{0x1B09788B00000000, 0x43BB09788B000000},
{0x4C5FCE800000000, 0x439317F3A0000000},
{0xCC0DE5BF00000000, 0x43E981BCB7E00000},
[tests] Cleanup of the RunRoundUint64ToFloat64 test. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1450353002 Cr-Commit-Position: refs/heads/master@{#32036}
2015-11-17 13:07:14 +00:00
{0x200000000, 0x4200000000000000},
{0x300000000, 0x4208000000000000},
{0x400000000, 0x4210000000000000},
{0x500000000, 0x4214000000000000},
{0x800000000, 0x4220000000000000},
{0x900000000, 0x4222000000000000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x273A798E187937A3, 0x43C39D3CC70C3C9C},
{0xECE3AF835495A16B, 0x43ED9C75F06A92B4},
{0xB668ECC11223344, 0x43A6CD1D98224467},
{0x9E, 0x4063C00000000000},
{0x43, 0x4050C00000000000},
{0xAF73, 0x40E5EE6000000000},
{0x116B, 0x40B16B0000000000},
{0x658ECC, 0x415963B300000000},
{0x2B3B4C, 0x41459DA600000000},
{0x88776655, 0x41E10EECCAA00000},
{0x70000000, 0x41DC000000000000},
{0x7200000, 0x419C800000000000},
{0x7FFFFFFF, 0x41DFFFFFFFC00000},
{0x56123761, 0x41D5848DD8400000},
{0x7FFFFF00, 0x41DFFFFFC0000000},
{0x761C4761EEEEEEEE, 0x43DD8711D87BBBBC},
{0x80000000EEEEEEEE, 0x43E00000001DDDDE},
{0x88888888DDDDDDDD, 0x43E11111111BBBBC},
{0xA0000000DDDDDDDD, 0x43E40000001BBBBC},
{0xDDDDDDDDAAAAAAAA, 0x43EBBBBBBBB55555},
{0xE0000000AAAAAAAA, 0x43EC000000155555},
{0xEEEEEEEEEEEEEEEE, 0x43EDDDDDDDDDDDDE},
{0xFFFFFFFDEEEEEEEE, 0x43EFFFFFFFBDDDDE},
{0xF0000000DDDDDDDD, 0x43EE0000001BBBBC},
{0x7FFFFFDDDDDDDD, 0x435FFFFFF7777777},
{0x3FFFFFAAAAAAAA, 0x434FFFFFD5555555},
{0x1FFFFFAAAAAAAA, 0x433FFFFFAAAAAAAA},
{0xFFFFF, 0x412FFFFE00000000},
{0x7FFFF, 0x411FFFFC00000000},
{0x3FFFF, 0x410FFFF800000000},
{0x1FFFF, 0x40FFFFF000000000},
{0xFFFF, 0x40EFFFE000000000},
{0x7FFF, 0x40DFFFC000000000},
{0x3FFF, 0x40CFFF8000000000},
{0x1FFF, 0x40BFFF0000000000},
{0xFFF, 0x40AFFE0000000000},
{0x7FF, 0x409FFC0000000000},
{0x3FF, 0x408FF80000000000},
{0x1FF, 0x407FF00000000000},
{0x3FFFFFFFFFFF, 0x42CFFFFFFFFFFF80},
{0x1FFFFFFFFFFF, 0x42BFFFFFFFFFFF00},
{0xFFFFFFFFFFF, 0x42AFFFFFFFFFFE00},
{0x7FFFFFFFFFF, 0x429FFFFFFFFFFC00},
{0x3FFFFFFFFFF, 0x428FFFFFFFFFF800},
{0x1FFFFFFFFFF, 0x427FFFFFFFFFF000},
{0x8000008000000000, 0x43E0000010000000},
{0x8000008000000001, 0x43E0000010000000},
{0x8000000000000400, 0x43E0000000000000},
{0x8000000000000401, 0x43E0000000000001}};
[tests] Cleanup of the RunRoundUint64ToFloat64 test. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1450353002 Cr-Commit-Position: refs/heads/master@{#32036}
2015-11-17 13:07:14 +00:00
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<double> m(MachineType::Uint64());
Implemented the RoundUint64ToFloat64 TurboFan operator for x64 and arm64. I don't see obvious implementations for mips64 and ppc64, so I would need help for these two platforms. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1436943002 Cr-Commit-Position: refs/heads/master@{#31946}
2015-11-11 19:12:25 +00:00
m.Return(m.RoundUint64ToFloat64(m.Parameter(0)));
[x64] Fixed a rounding error on x64 for the Uint64ToF64 conversion. The least significant bit of the input value may affect the result of the conversion through rounding. We OR the least significant with the second least significant bit to preserve it over the SHR instruction. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1435203003 Cr-Commit-Position: refs/heads/master@{#31969}
2015-11-12 19:35:47 +00:00
Fix gcc 4.9.2 signed-compare error. BUG= Review URL: https://codereview.chromium.org/1456543003 Cr-Commit-Position: refs/heads/master@{#32053}
2015-11-17 16:07:00 +00:00
for (size_t i = 0; i < arraysize(values); i++) {
[tests] Cleanup of the RunRoundUint64ToFloat64 test. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1450353002 Cr-Commit-Position: refs/heads/master@{#32036}
2015-11-17 13:07:14 +00:00
CHECK_EQ(bit_cast<double>(values[i].expected), m.Call(values[i].input));
}
Implemented the RoundUint64ToFloat64 TurboFan operator for x64 and arm64. I don't see obvious implementations for mips64 and ppc64, so I would need help for these two platforms. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1436943002 Cr-Commit-Position: refs/heads/master@{#31946}
2015-11-11 19:12:25 +00:00
}
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
TEST(RunRoundUint64ToFloat32) {
struct {
uint64_t input;
uint32_t expected;
} values[] = {{0x0, 0x0},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x1, 0x3F800000},
{0xFFFFFFFF, 0x4F800000},
{0x1B09788B, 0x4DD84BC4},
{0x4C5FCE8, 0x4C98BF9D},
{0xCC0DE5BF, 0x4F4C0DE6},
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
{0x2, 0x40000000},
{0x3, 0x40400000},
{0x4, 0x40800000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x5, 0x40A00000},
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
{0x8, 0x41000000},
{0x9, 0x41100000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0xFFFFFFFFFFFFFFFF, 0x5F800000},
{0xFFFFFFFFFFFFFFFE, 0x5F800000},
{0xFFFFFFFFFFFFFFFD, 0x5F800000},
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
{0x0, 0x0},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x100000000, 0x4F800000},
{0xFFFFFFFF00000000, 0x5F800000},
{0x1B09788B00000000, 0x5DD84BC4},
{0x4C5FCE800000000, 0x5C98BF9D},
{0xCC0DE5BF00000000, 0x5F4C0DE6},
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
{0x200000000, 0x50000000},
{0x300000000, 0x50400000},
{0x400000000, 0x50800000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x500000000, 0x50A00000},
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
{0x800000000, 0x51000000},
{0x900000000, 0x51100000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0x273A798E187937A3, 0x5E1CE9E6},
{0xECE3AF835495A16B, 0x5F6CE3B0},
{0xB668ECC11223344, 0x5D3668ED},
{0x9E, 0x431E0000},
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
{0x43, 0x42860000},
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
{0xAF73, 0x472F7300},
{0x116B, 0x458B5800},
{0x658ECC, 0x4ACB1D98},
{0x2B3B4C, 0x4A2CED30},
{0x88776655, 0x4F087766},
{0x70000000, 0x4EE00000},
{0x7200000, 0x4CE40000},
{0x7FFFFFFF, 0x4F000000},
{0x56123761, 0x4EAC246F},
{0x7FFFFF00, 0x4EFFFFFE},
{0x761C4761EEEEEEEE, 0x5EEC388F},
{0x80000000EEEEEEEE, 0x5F000000},
{0x88888888DDDDDDDD, 0x5F088889},
{0xA0000000DDDDDDDD, 0x5F200000},
{0xDDDDDDDDAAAAAAAA, 0x5F5DDDDE},
{0xE0000000AAAAAAAA, 0x5F600000},
{0xEEEEEEEEEEEEEEEE, 0x5F6EEEEF},
{0xFFFFFFFDEEEEEEEE, 0x5F800000},
{0xF0000000DDDDDDDD, 0x5F700000},
{0x7FFFFFDDDDDDDD, 0x5B000000},
{0x3FFFFFAAAAAAAA, 0x5A7FFFFF},
{0x1FFFFFAAAAAAAA, 0x59FFFFFD},
{0xFFFFF, 0x497FFFF0},
{0x7FFFF, 0x48FFFFE0},
{0x3FFFF, 0x487FFFC0},
{0x1FFFF, 0x47FFFF80},
{0xFFFF, 0x477FFF00},
{0x7FFF, 0x46FFFE00},
{0x3FFF, 0x467FFC00},
{0x1FFF, 0x45FFF800},
{0xFFF, 0x457FF000},
{0x7FF, 0x44FFE000},
{0x3FF, 0x447FC000},
{0x1FF, 0x43FF8000},
{0x3FFFFFFFFFFF, 0x56800000},
{0x1FFFFFFFFFFF, 0x56000000},
{0xFFFFFFFFFFF, 0x55800000},
{0x7FFFFFFFFFF, 0x55000000},
{0x3FFFFFFFFFF, 0x54800000},
{0x1FFFFFFFFFF, 0x54000000},
{0x8000008000000000, 0x5F000000},
{0x8000008000000001, 0x5F000001},
{0x8000000000000400, 0x5F000000},
{0x8000000000000401, 0x5F000000}};
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
BufferedRawMachineAssemblerTester<float> m(MachineType::Uint64());
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
m.Return(m.RoundUint64ToFloat32(m.Parameter(0)));
Fix gcc 4.9.2 signed-compare error. BUG= Review URL: https://codereview.chromium.org/1456543003 Cr-Commit-Position: refs/heads/master@{#32053}
2015-11-17 16:07:00 +00:00
for (size_t i = 0; i < arraysize(values); i++) {
Implemented the RoundUint64ToFloat32 TurboFan operator for x64, arm64, and ppc64. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1438013003 Cr-Commit-Position: refs/heads/master@{#32031}
2015-11-17 11:51:27 +00:00
CHECK_EQ(bit_cast<float>(values[i].expected), m.Call(values[i].input));
}
}
[turbofan] support for Int64 in CheckedLoad/CheckedStore on 64-bit platforms. This is to support WebAssembly 64-bit ints in the short term, since it currently uses CheckedLoad/CheckedStore for accesses to the memory. In the long run, we'll change this to be explicit bounds checks that throw on out of bounds. R=bmeurer@chromium.org BUG= Review URL: https://codereview.chromium.org/1310323006 Cr-Commit-Position: refs/heads/master@{#30555}
2015-09-03 10:45:35 +00:00
#endif
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
TEST(RunBitcastFloat32ToInt32) {
float input = 32.25;
RawMachineAssemblerTester<int32_t> m;
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.Return(m.BitcastFloat32ToInt32(
m.LoadFromPointer(&input, MachineType::Float32())));
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
FOR_FLOAT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
input = i;
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
int32_t expected = bit_cast<int32_t>(input);
CHECK_EQ(expected, m.Call());
}
}
[turbofan] Add the RoundInt32ToFloat32 operator to turbofan. The new operator converts an int32 input to float32. If the input cannot be represented exactly in float32, the value is rounded using the round-ties-even rounding mode (the default rounding mode). I provide implementations of the new operator for x64, ia32, arm, arm64, mips, mips64, ppc, and ppc64. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com, v8-ppc-ports@googlegroups.com Review URL: https://codereview.chromium.org/1589363002 Cr-Commit-Position: refs/heads/master@{#33347}
2016-01-16 13:11:40 +00:00
TEST(RunRoundInt32ToFloat32) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Int32());
m.Return(m.RoundInt32ToFloat32(m.Parameter(0)));
X87: Change the test case for X87 RunRoundInt32ToFloat32. The CL #33347 (https://codereview.chromium.org/1589363002) added the RunRoundInt32ToFloat32 test case and X87 failed at it. The reason is same as the CL #31808 (issue 1430943002, X87: Change the test case for X87 float operations), please refer: https://codereview.chromium.org/1430943002/. Here is the key comments from CL #31808 Some new test cases use CheckFloatEq(...) and CheckDoubleEq(...) function for result check. When GCC compiling the CheckFloatEq() and CheckDoubleEq() function, those inlined functions has different behavior comparing with GCC ia32 build and x87 build. The major difference is sse float register still has single precision rounding semantic. While X87 register has no such rounding precsion semantic when directly use register value. The V8 turbofan JITTed has exactly same result in both X87 and IA32 port. For CHECK_EQ(a, b) function, if a and b are doubles, it will has similar behaviors like CheckFloatEq(...) and CheckDoubleEq(...) function when compiled by GCC and causes the test case fail. So we add the following sentence to do type case to keep the same precision for RunRoundInt32ToFloat32. Such as: volatile double expect = static_cast<float>(*i). BUG= Review URL: https://codereview.chromium.org/1649323002 Cr-Commit-Position: refs/heads/master@{#33630}
2016-02-01 08:27:43 +00:00
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
volatile float expected = static_cast<float>(i);
CHECK_EQ(expected, m.Call(i));
X87: Change the test case for X87 RunRoundInt32ToFloat32. The CL #33347 (https://codereview.chromium.org/1589363002) added the RunRoundInt32ToFloat32 test case and X87 failed at it. The reason is same as the CL #31808 (issue 1430943002, X87: Change the test case for X87 float operations), please refer: https://codereview.chromium.org/1430943002/. Here is the key comments from CL #31808 Some new test cases use CheckFloatEq(...) and CheckDoubleEq(...) function for result check. When GCC compiling the CheckFloatEq() and CheckDoubleEq() function, those inlined functions has different behavior comparing with GCC ia32 build and x87 build. The major difference is sse float register still has single precision rounding semantic. While X87 register has no such rounding precsion semantic when directly use register value. The V8 turbofan JITTed has exactly same result in both X87 and IA32 port. For CHECK_EQ(a, b) function, if a and b are doubles, it will has similar behaviors like CheckFloatEq(...) and CheckDoubleEq(...) function when compiled by GCC and causes the test case fail. So we add the following sentence to do type case to keep the same precision for RunRoundInt32ToFloat32. Such as: volatile double expect = static_cast<float>(*i). BUG= Review URL: https://codereview.chromium.org/1649323002 Cr-Commit-Position: refs/heads/master@{#33630}
2016-02-01 08:27:43 +00:00
}
[turbofan] Add the RoundInt32ToFloat32 operator to turbofan. The new operator converts an int32 input to float32. If the input cannot be represented exactly in float32, the value is rounded using the round-ties-even rounding mode (the default rounding mode). I provide implementations of the new operator for x64, ia32, arm, arm64, mips, mips64, ppc, and ppc64. R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com, v8-ppc-ports@googlegroups.com Review URL: https://codereview.chromium.org/1589363002 Cr-Commit-Position: refs/heads/master@{#33347}
2016-01-16 13:11:40 +00:00
}
[turbofan] Add RoundUint32ToFloat32 operator to Turbofan. BUG= Review URL: https://codereview.chromium.org/1628133002 Cr-Commit-Position: refs/heads/master@{#33796}
2016-02-06 18:07:39 +00:00
TEST(RunRoundUint32ToFloat32) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Uint32());
m.Return(m.RoundUint32ToFloat32(m.Parameter(0)));
X87: Change the test case for X87 RunRoundUint32ToFloat32. The CL #33796 (https://codereview.chromium.org/1628133002) added the RunRoundUint32ToFloat32 test case and X87 failed at it. The reason is same as the CL #33630 (Issue 1649323002: X87: Change the test case for X87 RunRoundInt32ToFloat32), please refer: https://codereview.chromium.org/1649323002. Here is the key comments from CL #33630: Some new test cases use CheckFloatEq(...) and CheckDoubleEq(...) function for result check. When GCC compiling the CheckFloatEq() and CheckDoubleEq() function, those inlined functions has different behavior comparing with GCC ia32 build and x87 build. The major difference is sse float register still has single precision rounding semantic. While X87 register has no such rounding precsion semantic when directly use register value. The V8 turbofan JITTed has exactly same result in both X87 and IA32 port. For CHECK_EQ(a, b) function, if a and b are doubles, it will has similar behaviors like CheckFloatEq(...) and CheckDoubleEq(...) function when compiled by GCC and causes the test case fail. So we add the following sentence to do type case to keep the same precision for RunRoundUint32ToFloat32. Such as: volatile double expect = static_cast<float>(*i). BUG= Review URL: https://codereview.chromium.org/1714413002 Cr-Commit-Position: refs/heads/master@{#34202}
2016-02-23 01:49:46 +00:00
FOR_UINT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
volatile float expected = static_cast<float>(i);
CHECK_EQ(expected, m.Call(i));
X87: Change the test case for X87 RunRoundUint32ToFloat32. The CL #33796 (https://codereview.chromium.org/1628133002) added the RunRoundUint32ToFloat32 test case and X87 failed at it. The reason is same as the CL #33630 (Issue 1649323002: X87: Change the test case for X87 RunRoundInt32ToFloat32), please refer: https://codereview.chromium.org/1649323002. Here is the key comments from CL #33630: Some new test cases use CheckFloatEq(...) and CheckDoubleEq(...) function for result check. When GCC compiling the CheckFloatEq() and CheckDoubleEq() function, those inlined functions has different behavior comparing with GCC ia32 build and x87 build. The major difference is sse float register still has single precision rounding semantic. While X87 register has no such rounding precsion semantic when directly use register value. The V8 turbofan JITTed has exactly same result in both X87 and IA32 port. For CHECK_EQ(a, b) function, if a and b are doubles, it will has similar behaviors like CheckFloatEq(...) and CheckDoubleEq(...) function when compiled by GCC and causes the test case fail. So we add the following sentence to do type case to keep the same precision for RunRoundUint32ToFloat32. Such as: volatile double expect = static_cast<float>(*i). BUG= Review URL: https://codereview.chromium.org/1714413002 Cr-Commit-Position: refs/heads/master@{#34202}
2016-02-23 01:49:46 +00:00
}
[turbofan] Add RoundUint32ToFloat32 operator to Turbofan. BUG= Review URL: https://codereview.chromium.org/1628133002 Cr-Commit-Position: refs/heads/master@{#33796}
2016-02-06 18:07:39 +00:00
}
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
TEST(RunBitcastInt32ToFloat32) {
int32_t input = 1;
Reland "[test] Add nan bit patterns to uint{32,64}_vector" This is a reland of 6f93d59d9204101ee11c3ed9513c7012b0f75169. One more test had to be disabled (tracked by bug 6954), and two machops tests needed to be changed to use boxed floats and doubles. Original change's description: > [test] Add nan bit patterns to uint{32,64}_vector > > If you just cast those patterns to float or double and pass them > around, the quiet/signaling NaN bit might change. We had several bugs > around this, so add these patterns to the general input vectors. > > This uncovers a bug in the wasm interpreter, which will be fixed in a > separate CL. > > R=ahaas@chromium.org > > Bug: v8:6947, v8:6954 > Change-Id: I205b8ab784b087b1e4988190fa725df0b90e7ee0 > Reviewed-on: https://chromium-review.googlesource.com/725345 > Commit-Queue: Clemens Hammacher <clemensh@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#48731} Bug: v8:6947, v8:6954 Change-Id: I9a38b5d9324131c3950c537910371a73c93d2c13 Reviewed-on: https://chromium-review.googlesource.com/728439 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#48780}
2017-10-20 09:12:46 +00:00
Float32 output;
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
RawMachineAssemblerTester<int32_t> m;
m.StoreToPointer(
Reland "[test] Add nan bit patterns to uint{32,64}_vector" This is a reland of 6f93d59d9204101ee11c3ed9513c7012b0f75169. One more test had to be disabled (tracked by bug 6954), and two machops tests needed to be changed to use boxed floats and doubles. Original change's description: > [test] Add nan bit patterns to uint{32,64}_vector > > If you just cast those patterns to float or double and pass them > around, the quiet/signaling NaN bit might change. We had several bugs > around this, so add these patterns to the general input vectors. > > This uncovers a bug in the wasm interpreter, which will be fixed in a > separate CL. > > R=ahaas@chromium.org > > Bug: v8:6947, v8:6954 > Change-Id: I205b8ab784b087b1e4988190fa725df0b90e7ee0 > Reviewed-on: https://chromium-review.googlesource.com/725345 > Commit-Queue: Clemens Hammacher <clemensh@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#48731} Bug: v8:6947, v8:6954 Change-Id: I9a38b5d9324131c3950c537910371a73c93d2c13 Reviewed-on: https://chromium-review.googlesource.com/728439 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#48780}
2017-10-20 09:12:46 +00:00
output.get_bits_address(), MachineRepresentation::kFloat32,
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
m.BitcastInt32ToFloat32(m.LoadFromPointer(&input, MachineType::Int32())));
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
m.Return(m.Int32Constant(11));
FOR_INT32_INPUTS(i) {
[test] Modernize value helpers This CL changes the usage pattern from FOR_XXX_VALUES(i) { Use(*i); } to FOR_XXX_VALUES(i) { Use(i); } which is way more intuitive. Note that the replacement in the uses was done via regular expression, so it's purely mechanical. In two locations I removed unneeded braces around the macro, because they confused clang-format. I plan to do more cleanups (remove redundant assignments within the FOR_XXX_VALUES body) in a follow-up CL. R=mstarzinger@chromium.org Bug: v8:8562 Change-Id: I4329bfcf34e5b077d19b50f4204ceb3b4340fe61 Reviewed-on: https://chromium-review.googlesource.com/c/1449615 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#59287}
2019-02-01 10:37:04 +00:00
input = i;
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
CHECK_EQ(11, m.Call());
Reland "[test] Add nan bit patterns to uint{32,64}_vector" This is a reland of 6f93d59d9204101ee11c3ed9513c7012b0f75169. One more test had to be disabled (tracked by bug 6954), and two machops tests needed to be changed to use boxed floats and doubles. Original change's description: > [test] Add nan bit patterns to uint{32,64}_vector > > If you just cast those patterns to float or double and pass them > around, the quiet/signaling NaN bit might change. We had several bugs > around this, so add these patterns to the general input vectors. > > This uncovers a bug in the wasm interpreter, which will be fixed in a > separate CL. > > R=ahaas@chromium.org > > Bug: v8:6947, v8:6954 > Change-Id: I205b8ab784b087b1e4988190fa725df0b90e7ee0 > Reviewed-on: https://chromium-review.googlesource.com/725345 > Commit-Queue: Clemens Hammacher <clemensh@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#48731} Bug: v8:6947, v8:6954 Change-Id: I9a38b5d9324131c3950c537910371a73c93d2c13 Reviewed-on: https://chromium-review.googlesource.com/728439 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#48780}
2017-10-20 09:12:46 +00:00
Float32 expected = Float32::FromBits(input);
CHECK_EQ(expected.get_bits(), output.get_bits());
[turbofan] Add support for reinterpreting integers as floating point and vice versa. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1356913002 Cr-Commit-Position: refs/heads/master@{#30849}
2015-09-21 14:00:51 +00:00
}
}
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
TEST(RunComputedCodeObject) {
[cleanup] Removing GraphBuilderTester class GraphBuilderTester was introduced at a time where RawMachineAssembler was going to be deprecated (https://codereview.chromium.org/1423923003/). Now we know that it's not going to happen any time soon. Since GraphBuilderTester it's only used in one test which can use RawMachineAssembler, I updated it and removed the class. Now the .h file had another class, which is now the only class in the file. Therefore, I renamed it and updated the include calls to it. Also updated the include commands: some were not necessary, and some others could be moved to more aptly places. Bug: v8:9183 Change-Id: I44bf16090c0515b1b9ff6cbded1bdb0adb4e44e2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1594563 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#61269}
2019-05-07 09:18:58 +00:00
RawMachineAssemblerTester<int32_t> a;
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
a.Return(a.Int32Constant(33));
[cleanup] Removing GraphBuilderTester class GraphBuilderTester was introduced at a time where RawMachineAssembler was going to be deprecated (https://codereview.chromium.org/1423923003/). Now we know that it's not going to happen any time soon. Since GraphBuilderTester it's only used in one test which can use RawMachineAssembler, I updated it and removed the class. Now the .h file had another class, which is now the only class in the file. Therefore, I renamed it and updated the include calls to it. Also updated the include commands: some were not necessary, and some others could be moved to more aptly places. Bug: v8:9183 Change-Id: I44bf16090c0515b1b9ff6cbded1bdb0adb4e44e2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1594563 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#61269}
2019-05-07 09:18:58 +00:00
CHECK_EQ(33, a.Call());
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
[cleanup] Removing GraphBuilderTester class GraphBuilderTester was introduced at a time where RawMachineAssembler was going to be deprecated (https://codereview.chromium.org/1423923003/). Now we know that it's not going to happen any time soon. Since GraphBuilderTester it's only used in one test which can use RawMachineAssembler, I updated it and removed the class. Now the .h file had another class, which is now the only class in the file. Therefore, I renamed it and updated the include calls to it. Also updated the include commands: some were not necessary, and some others could be moved to more aptly places. Bug: v8:9183 Change-Id: I44bf16090c0515b1b9ff6cbded1bdb0adb4e44e2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1594563 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#61269}
2019-05-07 09:18:58 +00:00
RawMachineAssemblerTester<int32_t> b;
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
b.Return(b.Int32Constant(44));
[cleanup] Removing GraphBuilderTester class GraphBuilderTester was introduced at a time where RawMachineAssembler was going to be deprecated (https://codereview.chromium.org/1423923003/). Now we know that it's not going to happen any time soon. Since GraphBuilderTester it's only used in one test which can use RawMachineAssembler, I updated it and removed the class. Now the .h file had another class, which is now the only class in the file. Therefore, I renamed it and updated the include calls to it. Also updated the include commands: some were not necessary, and some others could be moved to more aptly places. Bug: v8:9183 Change-Id: I44bf16090c0515b1b9ff6cbded1bdb0adb4e44e2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1594563 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#61269}
2019-05-07 09:18:58 +00:00
CHECK_EQ(44, b.Call());
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
RawMachineAssemblerTester<int32_t> r(MachineType::Int32());
Move RMA::Label out of the class, so it can be forward declared. R=bmeurer@chromium.org, mstarzinger@chromium.org BUG=chromium:508898 LOG=Y Review URL: https://codereview.chromium.org/1477413002 Cr-Commit-Position: refs/heads/master@{#32400}
2015-11-30 11:28:50 +00:00
RawMachineLabel tlabel;
RawMachineLabel flabel;
RawMachineLabel merge;
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
r.Branch(r.Parameter(0), &tlabel, &flabel);
r.Bind(&tlabel);
[cleanup] Removing GraphBuilderTester class GraphBuilderTester was introduced at a time where RawMachineAssembler was going to be deprecated (https://codereview.chromium.org/1423923003/). Now we know that it's not going to happen any time soon. Since GraphBuilderTester it's only used in one test which can use RawMachineAssembler, I updated it and removed the class. Now the .h file had another class, which is now the only class in the file. Therefore, I renamed it and updated the include calls to it. Also updated the include commands: some were not necessary, and some others could be moved to more aptly places. Bug: v8:9183 Change-Id: I44bf16090c0515b1b9ff6cbded1bdb0adb4e44e2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1594563 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#61269}
2019-05-07 09:18:58 +00:00
Node* fa = r.HeapConstant(a.GetCode());
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
r.Goto(&merge);
r.Bind(&flabel);
[cleanup] Removing GraphBuilderTester class GraphBuilderTester was introduced at a time where RawMachineAssembler was going to be deprecated (https://codereview.chromium.org/1423923003/). Now we know that it's not going to happen any time soon. Since GraphBuilderTester it's only used in one test which can use RawMachineAssembler, I updated it and removed the class. Now the .h file had another class, which is now the only class in the file. Therefore, I renamed it and updated the include calls to it. Also updated the include commands: some were not necessary, and some others could be moved to more aptly places. Bug: v8:9183 Change-Id: I44bf16090c0515b1b9ff6cbded1bdb0adb4e44e2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1594563 Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#61269}
2019-05-07 09:18:58 +00:00
Node* fb = r.HeapConstant(b.GetCode());
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
r.Goto(&merge);
r.Bind(&merge);
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb);
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
// TODO(titzer): all this descriptor hackery is just to call the above
// functions as code objects instead of direct addresses.
[cleanup] Refactor CSignature helper The implementation can be greatly simplified by using variadic templates. R=mstarzinger@chromium.org Change-Id: I8dbeea3d570bf0fac83109f334c48dbe39aaa853 Reviewed-on: https://chromium-review.googlesource.com/859785 Commit-Queue: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#50611}
2018-01-16 09:26:02 +00:00
CSignatureOf<int32_t> sig;
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
CallDescriptor* c = Linkage::GetSimplifiedCDescriptor(r.zone(), &sig);
LinkageLocation ret[] = {c->GetReturnLocation(0)};
Signature<LinkageLocation> loc(1, 0, ret);
Normalize names of call descriptor local variables This is a purely cosmetic change. Rename all local variables and parameters of type CallDescriptor* to "call_descriptor". For locals that are now named "call_descriptor", use auto upon initialization, following the Google style guide (https://google.github.io/styleguide/cppguide.html#auto). Note: fields in structs and classes were not renamed in this CL. R=clemensh@chromium.org,mstarzinger@chromium.org,jarin@chromium.org Change-Id: Ic6f7afdba12f7b97741b098a9d0e0f58c41c587e Reviewed-on: https://chromium-review.googlesource.com/909866 Commit-Queue: Ben Titzer <titzer@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#51223}
2018-02-09 19:19:25 +00:00
auto call_descriptor = new (r.zone()) CallDescriptor( // --
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
CallDescriptor::kCallCodeObject, // kind
[turbofan] Make MachineType a pair of enums. MachineType is now a class with two enum fields: - MachineRepresentation - MachineSemantic Both enums are usable on their own, and this change switches some places from using MachineType to use just MachineRepresentation. Most notably: - register allocator now uses just the representation. - Phi and Select nodes only refer to representations. Review URL: https://codereview.chromium.org/1513543003 Cr-Commit-Position: refs/heads/master@{#32738}
2015-12-10 09:03:30 +00:00
MachineType::AnyTagged(), // target_type
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
c->GetInputLocation(0), // target_loc
&loc, // location_sig
0, // stack count
Operator::kNoProperties, // properties
c->CalleeSavedRegisters(), // callee saved
c->CalleeSavedFPRegisters(), // callee saved FP
CallDescriptor::kNoFlags, // flags
"c-call-as-code");
Normalize names of call descriptor local variables This is a purely cosmetic change. Rename all local variables and parameters of type CallDescriptor* to "call_descriptor". For locals that are now named "call_descriptor", use auto upon initialization, following the Google style guide (https://google.github.io/styleguide/cppguide.html#auto). Note: fields in structs and classes were not renamed in this CL. R=clemensh@chromium.org,mstarzinger@chromium.org,jarin@chromium.org Change-Id: Ic6f7afdba12f7b97741b098a9d0e0f58c41c587e Reviewed-on: https://chromium-review.googlesource.com/909866 Commit-Queue: Ben Titzer <titzer@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Cr-Commit-Position: refs/heads/master@{#51223}
2018-02-09 19:19:25 +00:00
Node* call = r.AddNode(r.common()->Call(call_descriptor), phi);
[turbofan] Fix calls to computed code objects. R=mstarzinger@chromium.org BUG= Review URL: https://codereview.chromium.org/1377423002 Cr-Commit-Position: refs/heads/master@{#31057}
2015-10-01 17:11:34 +00:00
r.Return(call);
CHECK_EQ(33, r.Call(1));
CHECK_EQ(44, r.Call(0));
}
Move compiler cctests into v8::internal::compiler namespace. This moves all cctest files for the compiler to live in the same namespace as the components they are testing. Hence we can avoid the forbidden using directives pulling in entire namespaces. From the Google C++ style guide: "You may not use a using-directive to make all names from a namespace available". This would be covered by presubmit linter checks if build/namespaces were not blacklisted. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1424943004 Cr-Commit-Position: refs/heads/master@{#31671}
2015-10-30 09:16:26 +00:00
[turbofan] Add an operator to access the parent frame pointer This functionality is useful for stubs that need to walk the stack. The new machine operator, LoadParentFramePointer dosn't force the currently compiling method to have a frame in contrast to LoadFramePointer. Instead, it adapts accordingly when frame elision is possible, making efficient stack walks possible without incurring a performance penalty for small stubs that can benefit from frame elision. R=bmeurer@chromium.org LOG=N Review URL: https://codereview.chromium.org/1695313002 Cr-Commit-Position: refs/heads/master@{#34014}
2016-02-16 07:28:57 +00:00
TEST(ParentFramePointer) {
RawMachineAssemblerTester<int32_t> r(MachineType::Int32());
RawMachineLabel tlabel;
RawMachineLabel flabel;
RawMachineLabel merge;
Node* frame = r.LoadFramePointer();
Node* parent_frame = r.LoadParentFramePointer();
frame = r.Load(MachineType::IntPtr(), frame);
r.Branch(r.WordEqual(frame, parent_frame), &tlabel, &flabel);
r.Bind(&tlabel);
Node* fa = r.Int32Constant(1);
r.Goto(&merge);
r.Bind(&flabel);
Node* fb = r.Int32Constant(0);
r.Goto(&merge);
r.Bind(&merge);
Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb);
r.Return(phi);
CHECK_EQ(1, r.Call(1));
}
[turbofan] Reland of `Add alignment parameter to StackSlot operator` Reland d8bfdb7a998adadc56aa5705a5998e75ceae7675 Original commit message: If alignment parameter is set, the memory returned by the StackSlot operator will be aligned according to the parameter. The implementation goes like this. If alignment parameter is set we allocate a bit more memory than actually needed and so we can move the beginning of the StackSlot in order to have it aligned. BUG= Review-Url: https://codereview.chromium.org/2874713003 Cr-Commit-Position: refs/heads/master@{#45339}
2017-05-16 12:27:56 +00:00
#if V8_HOST_ARCH_MIPS || V8_HOST_ARCH_MIPS64
TEST(StackSlotAlignment) {
RawMachineAssemblerTester<int32_t> r;
RawMachineLabel tlabel;
RawMachineLabel flabel;
RawMachineLabel merge;
int alignments[] = {4, 8, 16};
int alignment_count = arraysize(alignments);
Node* alignment_counter = r.Int32Constant(0);
for (int i = 0; i < alignment_count; i++) {
for (int j = 0; j < 5; j++) {
Node* stack_slot =
r.StackSlot(MachineRepresentation::kWord32, alignments[i]);
alignment_counter = r.Int32Add(
alignment_counter,
r.Word32And(stack_slot, r.Int32Constant(alignments[i] - 1)));
}
}
r.Return(alignment_counter);
MIPS[64]: Fix typo in StackSlotAlignment test BUG= Review-Url: https://codereview.chromium.org/2892713002 Cr-Commit-Position: refs/heads/master@{#45392}
2017-05-18 09:42:44 +00:00
CHECK_EQ(0, r.Call());
[turbofan] Reland of `Add alignment parameter to StackSlot operator` Reland d8bfdb7a998adadc56aa5705a5998e75ceae7675 Original commit message: If alignment parameter is set, the memory returned by the StackSlot operator will be aligned according to the parameter. The implementation goes like this. If alignment parameter is set we allocate a bit more memory than actually needed and so we can move the beginning of the StackSlot in order to have it aligned. BUG= Review-Url: https://codereview.chromium.org/2874713003 Cr-Commit-Position: refs/heads/master@{#45339}
2017-05-16 12:27:56 +00:00
}
#endif // V8_HOST_ARCH_MIPS || V8_HOST_ARCH_MIPS64
[arm64][turbofan] Fix add+shr for big shift values. Arm64 compiles "x +_64 (y >> shift)" into a single instruction if "shift" is a constant. The code generator expects that "shift" is a 32 bit constant. however, TurboFan can also pass in a 64 bit constant, which caused a crash in the code generator. With this CL we cast the constant of TurboFan to an int in the instruction selector and thereby satisfy the assumption of the code generator. This should be correct since the code generator anyways cast the "shift" to an int5 or int6 eventually. R=v8-arm-ports@googlegroups.com BUG=v8:5923 Review-Url: https://codereview.chromium.org/2669203005 Cr-Commit-Position: refs/heads/master@{#43036}
2017-02-08 11:52:16 +00:00
#if V8_TARGET_ARCH_64_BIT
TEST(Regression5923) {
{
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Int64());
m.Return(m.Int64Add(
m.Word64Shr(m.Parameter(0), m.Int64Constant(4611686018427387888)),
m.Parameter(0)));
int64_t input = 16;
m.Call(input);
}
{
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Int64());
m.Return(m.Int64Add(
m.Parameter(0),
m.Word64Shr(m.Parameter(0), m.Int64Constant(4611686018427387888))));
int64_t input = 16;
m.Call(input);
}
}
[arm64] A shift of 0 is not allowed in ubfx. R=bmeurer@chromium.org, v8-arm-ports@googlegroups.com BUG=v8:5951 Review-Url: https://codereview.chromium.org/2685943003 Cr-Original-Commit-Position: refs/heads/master@{#43090} Committed: https://chromium.googlesource.com/v8/v8/+/c46ccef921ee754d60283d132b9d19f64ae7b1ff Review-Url: https://codereview.chromium.org/2685943003 Cr-Commit-Position: refs/heads/master@{#43199}
2017-02-14 17:40:51 +00:00
TEST(Regression5951) {
BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Int64());
m.Return(m.Word64And(m.Word64Shr(m.Parameter(0), m.Int64Constant(0)),
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Int64Constant(0xFFFFFFFFFFFFFFFFl)));
[arm64] A shift of 0 is not allowed in ubfx. R=bmeurer@chromium.org, v8-arm-ports@googlegroups.com BUG=v8:5951 Review-Url: https://codereview.chromium.org/2685943003 Cr-Original-Commit-Position: refs/heads/master@{#43090} Committed: https://chromium.googlesource.com/v8/v8/+/c46ccef921ee754d60283d132b9d19f64ae7b1ff Review-Url: https://codereview.chromium.org/2685943003 Cr-Commit-Position: refs/heads/master@{#43199}
2017-02-14 17:40:51 +00:00
int64_t input = 1234;
CHECK_EQ(input, m.Call(input));
}
[arm64][turbofan] Do not use ubfx for shr+and combination for mask=0. R=titzer@chromium.org, v8-arm-ports@googlegroups.com BUG=v8:6046 Review-Url: https://codereview.chromium.org/2737493002 Cr-Commit-Position: refs/heads/master@{#43643}
2017-03-07 14:54:05 +00:00
TEST(Regression6046a) {
BufferedRawMachineAssemblerTester<int64_t> m;
m.Return(m.Word64Shr(m.Word64And(m.Int64Constant(0), m.Int64Constant(0)),
m.Int64Constant(64)));
CHECK_EQ(0, m.Call());
}
[arm64] The ubfx instruction can be used with a mask-width=64 The code-generator used i.InputInt6 to get the mask-width from the instruction. However, thereby 64 got wrapped to 0, which is an invalid mask width. I changed the i.InputInt6 to an i.InputInt32, which should be okay because the mask-width comes from base::bits::CountPopulation64. BUG=v8:6122 R=bmeurer@chromium.org, v8-arm-ports@googlegroups.com Review-Url: https://codereview.chromium.org/2755373002 Cr-Commit-Position: refs/heads/master@{#43927}
2017-03-20 09:42:37 +00:00
TEST(Regression6122) {
BufferedRawMachineAssemblerTester<int64_t> m;
m.Return(m.Word64Shr(m.Word64And(m.Int64Constant(59), m.Int64Constant(-1)),
m.Int64Constant(0)));
CHECK_EQ(59, m.Call());
}
#endif // V8_TARGET_ARCH_64_BIT
[arm64][turbofan] Do not use ubfx for shr+and combination for mask=0. R=titzer@chromium.org, v8-arm-ports@googlegroups.com BUG=v8:6046 Review-Url: https://codereview.chromium.org/2737493002 Cr-Commit-Position: refs/heads/master@{#43643}
2017-03-07 14:54:05 +00:00
TEST(Regression6046b) {
BufferedRawMachineAssemblerTester<int32_t> m;
m.Return(m.Word32Shr(m.Word32And(m.Int32Constant(0), m.Int32Constant(0)),
m.Int32Constant(32)));
CHECK_EQ(0, m.Call());
}
[arm64] The ubfx instruction can be used with a mask-width=64 The code-generator used i.InputInt6 to get the mask-width from the instruction. However, thereby 64 got wrapped to 0, which is an invalid mask width. I changed the i.InputInt6 to an i.InputInt32, which should be okay because the mask-width comes from base::bits::CountPopulation64. BUG=v8:6122 R=bmeurer@chromium.org, v8-arm-ports@googlegroups.com Review-Url: https://codereview.chromium.org/2755373002 Cr-Commit-Position: refs/heads/master@{#43927}
2017-03-20 09:42:37 +00:00
TEST(Regression6122b) {
BufferedRawMachineAssemblerTester<int32_t> m;
m.Return(m.Word32Shr(m.Word32And(m.Int32Constant(59), m.Int32Constant(-1)),
m.Int32Constant(0)));
CHECK_EQ(59, m.Call());
}
[arm64][turbofan] Fix add+shr for big shift values. Arm64 compiles "x +_64 (y >> shift)" into a single instruction if "shift" is a constant. The code generator expects that "shift" is a 32 bit constant. however, TurboFan can also pass in a 64 bit constant, which caused a crash in the code generator. With this CL we cast the constant of TurboFan to an int in the instruction selector and thereby satisfy the assumption of the code generator. This should be correct since the code generator anyways cast the "shift" to an int5 or int6 eventually. R=v8-arm-ports@googlegroups.com BUG=v8:5923 Review-Url: https://codereview.chromium.org/2669203005 Cr-Commit-Position: refs/heads/master@{#43036}
2017-02-08 11:52:16 +00:00
[arm64][turbofan] Tst instructions can have a shifted operand. This CL fixes a bug in the implementation of the code generation of kArm64Tst32, where the shift input operand of kArm64Tst32 was ignored. Please take a special look at the fix in kArm64Tst. I applied the fix there as well, but because of differences in the instruction selector I was not able to write a test for it. R=v8-arm-ports@googlegroups.com BUG=v8:6028 Review-Url: https://codereview.chromium.org/2729853003 Cr-Commit-Position: refs/heads/master@{#43555}
2017-03-02 19:46:09 +00:00
TEST(Regression6028) {
BufferedRawMachineAssemblerTester<int32_t> m;
m.Return(m.Word32Equal(
m.Word32And(m.Int32Constant(0x23),
m.Word32Sar(m.Int32Constant(1), m.Int32Constant(18))),
m.Int32Constant(0)));
CHECK_EQ(1, m.Call());
}
[arm64] Fix another ubfx corner case. This issue was fixed in VisitWord64And in 2f8ad11f. Port the fix to VisitWord32And. BUG= Review-Url: https://codereview.chromium.org/2815853002 Cr-Commit-Position: refs/heads/master@{#44636}
2017-04-13 09:51:20 +00:00
TEST(Regression5951_32bit) {
BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Int32());
m.Return(m.Word32And(m.Word32Shr(m.Parameter(0), m.Int32Constant(0)),
Normalize casing of hexadecimal digits This patch normalizes the casing of hexadecimal digits in escape sequences of the form `\xNN` and integer literals of the form `0xNNNN`. Previously, the V8 code base used an inconsistent mixture of uppercase and lowercase. Google’s C++ style guide uses uppercase in its examples: https://google.github.io/styleguide/cppguide.html#Non-ASCII_Characters Moreover, uppercase letters more clearly stand out from the lowercase `x` (or `u`) characters at the start, as well as lowercase letters elsewhere in strings. BUG=v8:7109 TBR=marja@chromium.org,titzer@chromium.org,mtrofin@chromium.org,mstarzinger@chromium.org,rossberg@chromium.org,yangguo@chromium.org,mlippautz@chromium.org NOPRESUBMIT=true Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I790e21c25d96ad5d95c8229724eb45d2aa9e22d6 Reviewed-on: https://chromium-review.googlesource.com/804294 Commit-Queue: Mathias Bynens <mathias@chromium.org> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#49810}
2017-12-02 00:30:37 +00:00
m.Int32Constant(0xFFFFFFFF)));
[arm64] Fix another ubfx corner case. This issue was fixed in VisitWord64And in 2f8ad11f. Port the fix to VisitWord32And. BUG= Review-Url: https://codereview.chromium.org/2815853002 Cr-Commit-Position: refs/heads/master@{#44636}
2017-04-13 09:51:20 +00:00
int32_t input = 1234;
CHECK_EQ(input, m.Call(input));
}
[arm64] Clear the upper 32 bits after a TruncateDoubleToI TruncateDoubleToI generated a 32-bit result but did not clear the upper 32 bits. This violated the invariant that the upper 32 bits should be cleared when the result is 32 bits. This change fixes the bug mentioned below. Clearing the upper 32 bits is also done on x64. R=v8-arm-ports@googlegroups.com, titzer@chromium.org, martyn.capewell@arm.com Bug: chromium:738952 Change-Id: I7e23e03fbed380ff08803db41fbae6382957ba08 Reviewed-on: https://chromium-review.googlesource.com/559671 Reviewed-by: Martyn Capewell <martyn.capewell@arm.com> Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#46440}
2017-07-06 05:58:37 +00:00
TEST(Regression738952) {
RawMachineAssemblerTester<int32_t> m;
int32_t sentinel = 1234;
// The index can be any value where the lower bits are 0 and the upper bits
// are not 0;
int64_t index = 3224;
index <<= 32;
double d = static_cast<double>(index);
m.Return(m.Load(MachineType::Int32(), m.PointerConstant(&sentinel),
m.TruncateFloat64ToWord32(m.Float64Constant(d))));
CHECK_EQ(sentinel, m.Call());
}
[x64] Do not encode RelocatableInt32Constant(0) with xor R=titzer@chromium.org Bug: v8:6640 Change-Id: I08bed124f7c6f6607b28844ea91bee90c1c1ab22 Reviewed-on: https://chromium-review.googlesource.com/586603 Reviewed-by: Ben Titzer <titzer@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#47033}
2017-07-26 14:10:52 +00:00
Move compiler cctests into v8::internal::compiler namespace. This moves all cctest files for the compiler to live in the same namespace as the components they are testing. Hence we can avoid the forbidden using directives pulling in entire namespaces. From the Google C++ style guide: "You may not use a using-directive to make all names from a namespace available". This would be covered by presubmit linter checks if build/namespaces were not blacklisted. R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/1424943004 Cr-Commit-Position: refs/heads/master@{#31671}
2015-10-30 09:16:26 +00:00
} // namespace compiler
} // namespace internal
} // namespace v8
Reference in New Issue Copy Permalink