mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
![Liam Appelbe](/assets/img/avatar_default.png)
The source report RPC needs to be able to distinguish branch coverage vs normal coverage token positions. So encode normal positions as 2 * pos and branch positions as 2 * pos + 1. TEST=CI Change-Id: I247796d1eb4c97947f9b38aa56bc318ecea09425 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/224320 Reviewed-by: Ryan Macnak <rmacnak@google.com> Commit-Queue: Liam Appelbe <liama@google.com>
228 lines
9.5 KiB
C++
228 lines
9.5 KiB
C++
// Copyright (c) 2016, 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_TOKEN_POSITION_H_
|
|
#define RUNTIME_VM_TOKEN_POSITION_H_
|
|
|
|
#include "platform/utils.h"
|
|
#include "vm/allocation.h"
|
|
|
|
namespace dart {
|
|
|
|
// The token space is organized as follows:
|
|
//
|
|
// Sentinel values start at -1 and move towards negative infinity:
|
|
// kNoSourcePos -> -1
|
|
// ClassifyingTokenPositions 1 -> -1 - 1
|
|
// ClassifyingTokenPositions N -> -1 - N
|
|
//
|
|
// Real token positions represent source offsets in some script, and are encoded
|
|
// as non-negative values which are equal to that offset.
|
|
//
|
|
// Synthetically created functions that correspond to user code are given
|
|
// starting token positions unique from other synthetic functions. The value for
|
|
// these token positions encode a unique non-negative value as a negative number
|
|
// within [kSmiMin32, -1 - N).
|
|
//
|
|
// For example:
|
|
// A synthetic token with value 0 is encoded as ((-1 - N) - (0 + 1)) = -2 - N.
|
|
// A synthetic token with value 1 is encoded as ((-1 - N) - (1 + 1)) = -3 - N.
|
|
//
|
|
// Note that the encoded value is _not_ related to any possible real token
|
|
// position, as two real token positions for different scripts can have the same
|
|
// value and thus cannot serve as a unique nonce for a synthetic node.
|
|
//
|
|
// All other nodes read from user code, such as non-synthetic functions, fields,
|
|
// etc., are given real starting token positions. All nodes coming from user
|
|
// code, both real or synthetic, with ending token positions have real ending
|
|
// token positions.
|
|
//
|
|
// This organization allows for ~1 billion token positions.
|
|
|
|
#define SENTINEL_TOKEN_DESCRIPTORS(V) \
|
|
V(NoSource, -1) \
|
|
V(Box, -2) \
|
|
V(ParallelMove, -3) \
|
|
V(TempMove, -4) \
|
|
V(Constant, -5) \
|
|
V(PushArgument, -6) \
|
|
V(ControlFlow, -7) \
|
|
V(Context, -8) \
|
|
V(MethodExtractor, -9) \
|
|
V(DeferredSlowPath, -10) \
|
|
V(DeferredDeoptInfo, -11) \
|
|
V(DartCodePrologue, -12) \
|
|
V(DartCodeEpilogue, -13) \
|
|
V(Last, -14) // Always keep this at the end.
|
|
|
|
// A token position represents either a debug safe source (real) position,
|
|
// non-debug safe unique (synthetic) position, or a classifying value used
|
|
// by the profiler.
|
|
class TokenPosition {
|
|
public:
|
|
uword Hash() const;
|
|
|
|
// Returns whether the token positions are equal. Defined for all token
|
|
// positions.
|
|
bool operator==(const TokenPosition& b) const { return value() == b.value(); }
|
|
|
|
// Returns whether the token positions are not equal. Defined for all token
|
|
// positions.
|
|
bool operator!=(const TokenPosition& b) const { return !(*this == b); }
|
|
|
|
// Returns whether the token position is less than [b]. Only defined for
|
|
// real token positions.
|
|
inline bool operator<(const TokenPosition& b) const {
|
|
return Pos() < b.Pos();
|
|
}
|
|
|
|
// Returns whether the token position is greater than [b]. Only defined for
|
|
// real token positions.
|
|
inline bool operator>(const TokenPosition& b) const { return b < *this; }
|
|
|
|
// Returns whether the token position is less than or equal to [b]. Only
|
|
// defined for real token positions.
|
|
inline bool operator<=(const TokenPosition& b) const { return !(*this > b); }
|
|
|
|
// Returns whether the token position is greater than or equal to [b]. Only
|
|
// defined for real token positions.
|
|
inline bool operator>=(const TokenPosition& b) const { return !(*this < b); }
|
|
|
|
// For real token positions, returns whether this is between [a] and [b],
|
|
// inclusive. If [a] or [b] is non-real, they are treated as less than
|
|
// any real token position.
|
|
//
|
|
// For synthetic token positions, returns whether [a] or [b] equals this.
|
|
//
|
|
// For other token positions, always returns false.
|
|
bool IsWithin(const TokenPosition& a, const TokenPosition& b) const {
|
|
if (IsReal()) return (a.value() <= value()) && (value() <= b.value());
|
|
if (IsSynthetic()) return (a == *this) || (b == *this);
|
|
return false;
|
|
}
|
|
|
|
// Returns [a] if both positions are not real, the real position if only one
|
|
// of [a] and [b] is real, or the minimum position of [a] and [b].
|
|
static const TokenPosition& Min(const TokenPosition& a,
|
|
const TokenPosition& b) {
|
|
if (!b.IsReal()) return a;
|
|
if (!a.IsReal()) return b;
|
|
return b.value() < a.value() ? b : a;
|
|
}
|
|
// Returns [a] if both positions are not real, the real position if only one
|
|
// of [a] and [b] is real, or the maximum position of [a] and [b].
|
|
static const TokenPosition& Max(const TokenPosition& a,
|
|
const TokenPosition& b) {
|
|
if (!b.IsReal()) return a;
|
|
if (!a.IsReal()) return b;
|
|
return b.value() > a.value() ? b : a;
|
|
}
|
|
|
|
// Compares two arbitrary source positions for use in sorting, where a
|
|
// negative return means [a] sorts before [b], a return of 0 means [a] is the
|
|
// same as [b], and a positive return means [a] sorts after [b].
|
|
//
|
|
// Does _not_ correspond to the relational operators on token positions, as
|
|
// this also allows comparison of kNoSource, classifying, and synthetic token
|
|
// positions to each other.
|
|
static intptr_t CompareForSorting(const TokenPosition& a,
|
|
const TokenPosition& b) {
|
|
return a.value() - b.value();
|
|
}
|
|
|
|
static constexpr int32_t kMaxSentinelDescriptors = 64;
|
|
|
|
#define DECLARE_VALUES(name, value) \
|
|
static constexpr int32_t k##name##Pos = value; \
|
|
static const TokenPosition k##name;
|
|
SENTINEL_TOKEN_DESCRIPTORS(DECLARE_VALUES);
|
|
#undef DECLARE_VALUES
|
|
// Check assumptions used in Is<X> methods below.
|
|
#define CHECK_VALUES(name, value) \
|
|
static_assert(k##name##Pos < 0, "Non-negative sentinel descriptor"); \
|
|
static_assert( \
|
|
k##name##Pos == kNoSourcePos || k##name##Pos <= kBoxPos, \
|
|
"Box sentinel descriptor is not greatest classifying sentinel value"); \
|
|
static_assert(kLastPos <= k##name##Pos, \
|
|
"Last sentinel descriptor is not least sentinel valu"); \
|
|
SENTINEL_TOKEN_DESCRIPTORS(CHECK_VALUES);
|
|
#undef CHECK_VALUES
|
|
static_assert(kLastPos > -kMaxSentinelDescriptors,
|
|
"More sentinel descriptors than expected");
|
|
|
|
static constexpr int32_t kMinSourcePos = 0;
|
|
static const TokenPosition kMinSource;
|
|
static constexpr int32_t kMaxSourcePos =
|
|
kSmiMax32 - kMaxSentinelDescriptors - 2;
|
|
static const TokenPosition kMaxSource;
|
|
|
|
// Decode from a serialized form.
|
|
static TokenPosition Deserialize(int32_t value);
|
|
|
|
// Encode into a serialized form.
|
|
int32_t Serialize() const;
|
|
|
|
// Given a real token position, returns the next real token position.
|
|
TokenPosition Next() {
|
|
ASSERT(IsReal());
|
|
return TokenPosition(value_ + 1);
|
|
}
|
|
|
|
// Return the source position for real token positions.
|
|
inline intptr_t Pos() const {
|
|
ASSERT(IsReal());
|
|
return value_;
|
|
}
|
|
|
|
// Is |this| a classifying sentinel source position?
|
|
// Classifying positions are used by the profiler to group instructions whose
|
|
// cost isn't naturally attributable to a source location.
|
|
inline bool IsClassifying() const {
|
|
return (value_ >= kBox.value()) && (value_ <= kLast.value());
|
|
}
|
|
|
|
// Is |this| the no source position sentinel?
|
|
inline bool IsNoSource() const { return value_ == kNoSourcePos; }
|
|
|
|
// Is |this| a synthetic source position?
|
|
// Synthetic source positions are used by the profiler to attribute ticks to a
|
|
// pieces of source, but ignored by the debugger as potential breakpoints.
|
|
inline bool IsSynthetic() const { return value_ < kLastPos; }
|
|
|
|
// Is |this| a real source position?
|
|
inline bool IsReal() const { return value_ >= kMinSourcePos; }
|
|
|
|
// Is |this| a debug pause source position?
|
|
inline bool IsDebugPause() const { return IsReal(); }
|
|
|
|
// Creates a synthetic source position from a non-negative value.
|
|
static TokenPosition Synthetic(intptr_t value) {
|
|
ASSERT(value >= 0 && value <= kMaxSourcePos);
|
|
return TokenPosition((kLastPos - 1) - value);
|
|
}
|
|
|
|
// Encode the token position for storage in the coverage array.
|
|
intptr_t EncodeCoveragePosition(bool is_branch_coverage);
|
|
|
|
// Decode a token position that was stored in the coverage array.
|
|
static TokenPosition DecodeCoveragePosition(intptr_t encoded_position,
|
|
bool* is_branch_coverage);
|
|
|
|
const char* ToCString() const;
|
|
|
|
private:
|
|
explicit TokenPosition(intptr_t value) : value_(value) {}
|
|
|
|
// The raw value of this TokenPosition.
|
|
intptr_t value() const { return value_; }
|
|
|
|
int32_t value_;
|
|
|
|
DISALLOW_ALLOCATION();
|
|
};
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_TOKEN_POSITION_H_
|