languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-09-15 23:09:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
dart-sdk/runtime/vm/pointer_tagging.h

104 lines
4 KiB
C
Raw Normal View History

[vm] Decouple assemblers from runtime. This is the next step towards preventing compiler from directly peeking into runtime and instead interact with runtime through a well defined surface. The goal of the refactoring to locate all places where compiler accesses some runtime information and partion those accesses into two categories: - creating objects in the host runtime (e.g. allocating strings, numbers, etc) during compilation; - accessing properties of the target runtime (e.g. offsets of fields) to embed those into the generated code; This change introduces dart::compiler and dart::compiler::target namespaces. All code in the compiler will gradually be moved into dart::compiler namespace. One of the motivations for this change is to be able to prevent access to globally defined host constants like kWordSize by shadowing them in the dart::compiler namespace. The nested namespace dart::compiler::target hosts all information about target runtime that compiler could access, e.g. compiler::target::kWordSize defines word size of the target which will eventually be made different from the host kWordSize (defined by dart::kWordSize). The API for compiler to runtime interaction is placed into compiler_api.h. Note that we still permit runtime to access compiler internals directly - this is not going to be decoupled as part of this work. Issue https://github.com/dart-lang/sdk/issues/31709 Change-Id: If4396d295879391becfa6c38d4802bbff81f5b20 Reviewed-on: https://dart-review.googlesource.com/c/90242 Commit-Queue: Vyacheslav Egorov <vegorov@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-01-25 16:45:13 +00:00
// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#ifndef RUNTIME_VM_POINTER_TAGGING_H_
#define RUNTIME_VM_POINTER_TAGGING_H_
[gardening] Migrate most files to be implicit-bool-conversion free Issue https://dart-review.googlesource.com/c/sdk/+/115701 Change-Id: Ib579f0bbc8d694aec74afd837217316a10baf910 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/115707 Commit-Queue: Martin Kustermann <kustermann@google.com> Reviewed-by: Ryan Macnak <rmacnak@google.com> Reviewed-by: Daco Harkes <dacoharkes@google.com>
2019-09-05 21:41:42 +00:00
#include "platform/assert.h"
#include "platform/globals.h"
[vm] Decouple assemblers from runtime. This is the next step towards preventing compiler from directly peeking into runtime and instead interact with runtime through a well defined surface. The goal of the refactoring to locate all places where compiler accesses some runtime information and partion those accesses into two categories: - creating objects in the host runtime (e.g. allocating strings, numbers, etc) during compilation; - accessing properties of the target runtime (e.g. offsets of fields) to embed those into the generated code; This change introduces dart::compiler and dart::compiler::target namespaces. All code in the compiler will gradually be moved into dart::compiler namespace. One of the motivations for this change is to be able to prevent access to globally defined host constants like kWordSize by shadowing them in the dart::compiler namespace. The nested namespace dart::compiler::target hosts all information about target runtime that compiler could access, e.g. compiler::target::kWordSize defines word size of the target which will eventually be made different from the host kWordSize (defined by dart::kWordSize). The API for compiler to runtime interaction is placed into compiler_api.h. Note that we still permit runtime to access compiler internals directly - this is not going to be decoupled as part of this work. Issue https://github.com/dart-lang/sdk/issues/31709 Change-Id: If4396d295879391becfa6c38d4802bbff81f5b20 Reviewed-on: https://dart-review.googlesource.com/c/90242 Commit-Queue: Vyacheslav Egorov <vegorov@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-01-25 16:45:13 +00:00
// This header defines constants associated with pointer tagging:
//
// * which bits determine whether or not this is a Smi value or a heap
// pointer;
// * which bits determine whether this is a pointer into a new or an old
// space.
namespace dart {
// Dart VM aligns all objects by 2 words in in the old space and misaligns them
// in new space. This allows to distinguish new and old pointers by their bits.
//
// Note: these bits depend on the word size.
template <intptr_t word_size, intptr_t word_size_log2>
struct ObjectAlignment {
// Alignment offsets are used to determine object age.
static constexpr intptr_t kNewObjectAlignmentOffset = word_size;
static constexpr intptr_t kOldObjectAlignmentOffset = 0;
static constexpr intptr_t kNewObjectBitPosition = word_size_log2;
// Object sizes are aligned to kObjectAlignment.
static constexpr intptr_t kObjectAlignment = 2 * word_size;
static constexpr intptr_t kObjectAlignmentLog2 = word_size_log2 + 1;
static constexpr intptr_t kObjectAlignmentMask = kObjectAlignment - 1;
[vm] Distinguish between bool objects by a single bit in their pointers. Allocate the canonical true and false objects right after the null object such that their pointers are the same except for a single bit. This enables a number of optimizations: - Test of a bool value becomes a bit test when it is known that the value is a bool. on ARM64, this bit test can be combined with the branch. - Negation of a bool value becomes an xor when it is known that the value is a bool. - Load of a bool value becomes an immediate add with the null register on ARM64. This is a reland of f8ead09ba2af6f7f38a5f763388c3a1c45501c84 Change-Id: Iadb2169f80d3731153df3a93772f6142c3197260 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/142375 Reviewed-by: Martin Kustermann <kustermann@google.com> Commit-Queue: Aske Simon Christensen <askesc@google.com>
2020-04-06 10:36:50 +00:00
// Discriminate between true and false based on the alignment bit.
static constexpr intptr_t kBoolValueBitPosition = kObjectAlignmentLog2;
static constexpr intptr_t kBoolValueMask = 1 << kBoolValueBitPosition;
[vm, compiler] Don't touch memory in AssertBoolean and BooleanNegate. AssertBoolean may assume its input is nullable bool. BooleanNegate may assume its input is non-nullable bool. Use fixed alignment bits to distinguish true, false and null. TEST=ci Change-Id: Ife694e66c1225d943881c2325cd67f18575a47e7 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/189240 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com>
2021-03-09 20:27:00 +00:00
// Discriminate between bool and null based on bit after the alignment bit.
static constexpr intptr_t kBoolVsNullBitPosition = kObjectAlignmentLog2 + 1;
static constexpr intptr_t kBoolVsNullMask = 1 << kBoolVsNullBitPosition;
[vm] Distinguish between bool objects by a single bit in their pointers. Allocate the canonical true and false objects right after the null object such that their pointers are the same except for a single bit. This enables a number of optimizations: - Test of a bool value becomes a bit test when it is known that the value is a bool. on ARM64, this bit test can be combined with the branch. - Negation of a bool value becomes an xor when it is known that the value is a bool. - Load of a bool value becomes an immediate add with the null register on ARM64. This is a reland of f8ead09ba2af6f7f38a5f763388c3a1c45501c84 Change-Id: Iadb2169f80d3731153df3a93772f6142c3197260 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/142375 Reviewed-by: Martin Kustermann <kustermann@google.com> Commit-Queue: Aske Simon Christensen <askesc@google.com>
2020-04-06 10:36:50 +00:00
static constexpr intptr_t kTrueOffsetFromNull = kObjectAlignment * 2;
static constexpr intptr_t kFalseOffsetFromNull = kObjectAlignment * 3;
[vm] Decouple assemblers from runtime. This is the next step towards preventing compiler from directly peeking into runtime and instead interact with runtime through a well defined surface. The goal of the refactoring to locate all places where compiler accesses some runtime information and partion those accesses into two categories: - creating objects in the host runtime (e.g. allocating strings, numbers, etc) during compilation; - accessing properties of the target runtime (e.g. offsets of fields) to embed those into the generated code; This change introduces dart::compiler and dart::compiler::target namespaces. All code in the compiler will gradually be moved into dart::compiler namespace. One of the motivations for this change is to be able to prevent access to globally defined host constants like kWordSize by shadowing them in the dart::compiler namespace. The nested namespace dart::compiler::target hosts all information about target runtime that compiler could access, e.g. compiler::target::kWordSize defines word size of the target which will eventually be made different from the host kWordSize (defined by dart::kWordSize). The API for compiler to runtime interaction is placed into compiler_api.h. Note that we still permit runtime to access compiler internals directly - this is not going to be decoupled as part of this work. Issue https://github.com/dart-lang/sdk/issues/31709 Change-Id: If4396d295879391becfa6c38d4802bbff81f5b20 Reviewed-on: https://dart-review.googlesource.com/c/90242 Commit-Queue: Vyacheslav Egorov <vegorov@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-01-25 16:45:13 +00:00
};
using HostObjectAlignment = ObjectAlignment<kWordSize, kWordSizeLog2>;
static constexpr intptr_t kNewObjectAlignmentOffset =
HostObjectAlignment::kNewObjectAlignmentOffset;
static constexpr intptr_t kOldObjectAlignmentOffset =
HostObjectAlignment::kOldObjectAlignmentOffset;
static constexpr intptr_t kNewObjectBitPosition =
HostObjectAlignment::kNewObjectBitPosition;
static constexpr intptr_t kObjectAlignment =
HostObjectAlignment::kObjectAlignment;
static constexpr intptr_t kObjectAlignmentLog2 =
HostObjectAlignment::kObjectAlignmentLog2;
static constexpr intptr_t kObjectAlignmentMask =
HostObjectAlignment::kObjectAlignmentMask;
[vm] Distinguish between bool objects by a single bit in their pointers. Allocate the canonical true and false objects right after the null object such that their pointers are the same except for a single bit. This enables a number of optimizations: - Test of a bool value becomes a bit test when it is known that the value is a bool. on ARM64, this bit test can be combined with the branch. - Negation of a bool value becomes an xor when it is known that the value is a bool. - Load of a bool value becomes an immediate add with the null register on ARM64. This is a reland of f8ead09ba2af6f7f38a5f763388c3a1c45501c84 Change-Id: Iadb2169f80d3731153df3a93772f6142c3197260 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/142375 Reviewed-by: Martin Kustermann <kustermann@google.com> Commit-Queue: Aske Simon Christensen <askesc@google.com>
2020-04-06 10:36:50 +00:00
static constexpr intptr_t kBoolValueBitPosition =
HostObjectAlignment::kBoolValueBitPosition;
static constexpr intptr_t kBoolValueMask = HostObjectAlignment::kBoolValueMask;
[vm, compiler] Don't touch memory in AssertBoolean and BooleanNegate. AssertBoolean may assume its input is nullable bool. BooleanNegate may assume its input is non-nullable bool. Use fixed alignment bits to distinguish true, false and null. TEST=ci Change-Id: Ife694e66c1225d943881c2325cd67f18575a47e7 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/189240 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com>
2021-03-09 20:27:00 +00:00
static constexpr intptr_t kBoolVsNullBitPosition =
HostObjectAlignment::kBoolVsNullBitPosition;
static constexpr intptr_t kBoolVsNullMask =
HostObjectAlignment::kBoolVsNullMask;
[vm] Distinguish between bool objects by a single bit in their pointers. Allocate the canonical true and false objects right after the null object such that their pointers are the same except for a single bit. This enables a number of optimizations: - Test of a bool value becomes a bit test when it is known that the value is a bool. on ARM64, this bit test can be combined with the branch. - Negation of a bool value becomes an xor when it is known that the value is a bool. - Load of a bool value becomes an immediate add with the null register on ARM64. This is a reland of f8ead09ba2af6f7f38a5f763388c3a1c45501c84 Change-Id: Iadb2169f80d3731153df3a93772f6142c3197260 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/142375 Reviewed-by: Martin Kustermann <kustermann@google.com> Commit-Queue: Aske Simon Christensen <askesc@google.com>
2020-04-06 10:36:50 +00:00
static constexpr intptr_t kTrueOffsetFromNull =
HostObjectAlignment::kTrueOffsetFromNull;
static constexpr intptr_t kFalseOffsetFromNull =
HostObjectAlignment::kFalseOffsetFromNull;
[vm] Decouple assemblers from runtime. This is the next step towards preventing compiler from directly peeking into runtime and instead interact with runtime through a well defined surface. The goal of the refactoring to locate all places where compiler accesses some runtime information and partion those accesses into two categories: - creating objects in the host runtime (e.g. allocating strings, numbers, etc) during compilation; - accessing properties of the target runtime (e.g. offsets of fields) to embed those into the generated code; This change introduces dart::compiler and dart::compiler::target namespaces. All code in the compiler will gradually be moved into dart::compiler namespace. One of the motivations for this change is to be able to prevent access to globally defined host constants like kWordSize by shadowing them in the dart::compiler namespace. The nested namespace dart::compiler::target hosts all information about target runtime that compiler could access, e.g. compiler::target::kWordSize defines word size of the target which will eventually be made different from the host kWordSize (defined by dart::kWordSize). The API for compiler to runtime interaction is placed into compiler_api.h. Note that we still permit runtime to access compiler internals directly - this is not going to be decoupled as part of this work. Issue https://github.com/dart-lang/sdk/issues/31709 Change-Id: If4396d295879391becfa6c38d4802bbff81f5b20 Reviewed-on: https://dart-review.googlesource.com/c/90242 Commit-Queue: Vyacheslav Egorov <vegorov@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-01-25 16:45:13 +00:00
Reland "[vm, compiler] Reduce alignment of Instructions and remove some debugging trap instructions." Further adjustments for simarm_x64. Flutter Gallery: ARM32 Instructions(CodeSize): 6979424 -> 6771856 (-2.97%) Total(CodeSize): 10855163 -> 10363319 (-4.53%) ARM64 Instructions(CodeSize): 7334368 -> 6817312 (-7.05%) Total(CodeSize): 11505069 -> 10771431 (-6.37%) Bug: https://github.com/dart-lang/sdk/issues/37103 Bug: https://github.com/dart-lang/sdk/issues/38452 Change-Id: I2bb44e7b2c002d53830b66cf4aedc4455c815326 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/119440 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-10-17 21:45:38 +00:00
// The largest value of kObjectAlignment across all configurations.
static constexpr intptr_t kMaxObjectAlignment = 16;
COMPILE_ASSERT(kMaxObjectAlignment >= kObjectAlignment);
[vm] Decouple assemblers from runtime. This is the next step towards preventing compiler from directly peeking into runtime and instead interact with runtime through a well defined surface. The goal of the refactoring to locate all places where compiler accesses some runtime information and partion those accesses into two categories: - creating objects in the host runtime (e.g. allocating strings, numbers, etc) during compilation; - accessing properties of the target runtime (e.g. offsets of fields) to embed those into the generated code; This change introduces dart::compiler and dart::compiler::target namespaces. All code in the compiler will gradually be moved into dart::compiler namespace. One of the motivations for this change is to be able to prevent access to globally defined host constants like kWordSize by shadowing them in the dart::compiler namespace. The nested namespace dart::compiler::target hosts all information about target runtime that compiler could access, e.g. compiler::target::kWordSize defines word size of the target which will eventually be made different from the host kWordSize (defined by dart::kWordSize). The API for compiler to runtime interaction is placed into compiler_api.h. Note that we still permit runtime to access compiler internals directly - this is not going to be decoupled as part of this work. Issue https://github.com/dart-lang/sdk/issues/31709 Change-Id: If4396d295879391becfa6c38d4802bbff81f5b20 Reviewed-on: https://dart-review.googlesource.com/c/90242 Commit-Queue: Vyacheslav Egorov <vegorov@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-01-25 16:45:13 +00:00
// On all targets heap pointers are tagged by set least significant bit.
//
// To recover address of the actual heap object kHeapObjectTag needs to be
// subtracted from the tagged pointer value.
//
// Smi-s (small integers) have least significant bit cleared.
//
// To recover the integer value tagged pointer value needs to be shifted
// right by kSmiTagShift.
enum {
kSmiTag = 0,
kHeapObjectTag = 1,
kSmiTagSize = 1,
kSmiTagMask = 1,
kSmiTagShift = 1,
};
[vm, arm64] Reserve a register for pointer decompression. TEST=ci Change-Id: I661cffec3de58fbbba70e13e9b4ad612574f494b Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/185200 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Liam Appelbe <liama@google.com>
2021-02-18 17:47:37 +00:00
#if !defined(DART_COMPRESSED_POINTERS)
static constexpr uintptr_t kHeapBaseMask = 0;
#else
static constexpr uintptr_t kHeapBaseMask = ~(4LL * GB - 1);
#endif
[vm] Decouple assemblers from runtime. This is the next step towards preventing compiler from directly peeking into runtime and instead interact with runtime through a well defined surface. The goal of the refactoring to locate all places where compiler accesses some runtime information and partion those accesses into two categories: - creating objects in the host runtime (e.g. allocating strings, numbers, etc) during compilation; - accessing properties of the target runtime (e.g. offsets of fields) to embed those into the generated code; This change introduces dart::compiler and dart::compiler::target namespaces. All code in the compiler will gradually be moved into dart::compiler namespace. One of the motivations for this change is to be able to prevent access to globally defined host constants like kWordSize by shadowing them in the dart::compiler namespace. The nested namespace dart::compiler::target hosts all information about target runtime that compiler could access, e.g. compiler::target::kWordSize defines word size of the target which will eventually be made different from the host kWordSize (defined by dart::kWordSize). The API for compiler to runtime interaction is placed into compiler_api.h. Note that we still permit runtime to access compiler internals directly - this is not going to be decoupled as part of this work. Issue https://github.com/dart-lang/sdk/issues/31709 Change-Id: If4396d295879391becfa6c38d4802bbff81f5b20 Reviewed-on: https://dart-review.googlesource.com/c/90242 Commit-Queue: Vyacheslav Egorov <vegorov@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
2019-01-25 16:45:13 +00:00
} // namespace dart
#endif // RUNTIME_VM_POINTER_TAGGING_H_
Reference in a new issue Copy permalink