AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert "[flags] warn about contradictory flags"

Browse Source 
This reverts commit b8f9166664.

Reason for revert: Fails gc-stress (https://ci.chromium.org/p/v8/builders/ci/V8%20Linux%20-%20gc%20stress/28341).

Original change's description:
> [flags] warn about contradictory flags
> 
> Design Doc: https://docs.google.com/document/d/1lkvu8crkK7Ei39qjkPCFijpNyxWXsOktG9GB-7K34jM/
> 
> Bug: v8:10577
> Change-Id: Ib9cfdffa401c48c895bf31caed5ee03545beddab
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2154792
> Reviewed-by: Clemens Backes <clemensb@chromium.org>
> Reviewed-by: Michael Achenbach <machenbach@chromium.org>
> Reviewed-by: Georg Neis <neis@chromium.org>
> Reviewed-by: Tamer Tas <tmrts@chromium.org>
> Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#68168}

TBR=machenbach@chromium.org,neis@chromium.org,clemensb@chromium.org,tebbi@chromium.org,tmrts@chromium.org

Change-Id: Ia1e3373fbb4c369594ceb98eb560e3ccf2cb8780
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: v8:10577
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2230523
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Commit-Queue: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#68169}
This commit is contained in:
Clemens Backes 2020-06-04 10:19:46 +00:00 committed by Commit Bot
parent b8f9166664
commit b342cbb20b
24 changed files with 145 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/d8/d8.cc
View File

@ -3172,7 +3172,6 @@ bool Shell::SetOptions(int argc, char* argv[]) {
}
}
i::FLAG_abort_on_contradictory_flags = true;
v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
options.mock_arraybuffer_allocator = i::FLAG_mock_arraybuffer_allocator;
options.mock_arraybuffer_allocator_limit =
@ -3619,11 +3618,12 @@ class D8Testing {
"--max-inlined-bytecode-size=999999 "
"--max-inlined-bytecode-size-cumulative=999999 "
"--noalways-opt";
static const char* kForcedOptimizations = "--always-opt";
if (run < GetStressRuns() - 1) {
V8::SetFlagsFromString(kLazyOptimizations);
if (run == GetStressRuns() - 1) {
V8::SetFlagsFromString(kForcedOptimizations);
} else {
i::FLAG_always_opt = true;
V8::SetFlagsFromString(kLazyOptimizations);
}
}

73
src/flags/flag-definitions.h
View File

@ -15,11 +15,6 @@
#define DEFINE_IMPLICATION(whenflag, thenflag) \
DEFINE_VALUE_IMPLICATION(whenflag, thenflag, true)
// A weak implication will be overwritten by a normal implication or by an
// explicit flag.
#define DEFINE_WEAK_IMPLICATION(whenflag, thenflag) \
DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, true)
#define DEFINE_NEG_IMPLICATION(whenflag, thenflag) \
DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false)
@ -64,22 +59,14 @@
// We produce the code to set flags when it is implied by another flag.
#elif defined(FLAG_MODE_DEFINE_IMPLICATIONS)
#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \
changed |= TriggerImplication(FLAG_##whenflag, #whenflag, &FLAG_##thenflag, \
value, false);
// A weak implication will be overwritten by a normal implication or by an
// explicit flag.
#define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value) \
changed |= TriggerImplication(FLAG_##whenflag, #whenflag, &FLAG_##thenflag, \
value, true);
#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \
if (FLAG_##whenflag) FLAG_##thenflag = value;
#define DEFINE_GENERIC_IMPLICATION(whenflag, statement) \
if (FLAG_##whenflag) statement;
#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \
changed |= TriggerImplication(!FLAG_##whenflag, #whenflag, &FLAG_##thenflag, \
value, false);
#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \
if (!FLAG_##whenflag) FLAG_##thenflag = value;
// We apply a generic macro to the flags.
#elif defined(FLAG_MODE_APPLY)
@ -107,10 +94,6 @@
#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value)
#endif
#ifndef DEFINE_WEAK_VALUE_IMPLICATION
#define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value)
#endif
#ifndef DEFINE_GENERIC_IMPLICATION
#define DEFINE_GENERIC_IMPLICATION(whenflag, statement)
#endif
@ -220,14 +203,6 @@ struct MaybeBoolFlag {
//
#define FLAG FLAG_FULL
// ATTENTION: This is set to true by default in d8. But For API compatibility,
// it generally defaults to false.
DEFINE_BOOL(abort_on_contradictory_flags, false,
"Disallow flags or implications overriding each other.")
// This implication is also hard-coded into the flags processing to make sure it
// becomes active before we even process subsequent flags.
DEFINE_NEG_IMPLICATION(fuzzing, abort_on_contradictory_flags)
// Flags for language modes and experimental language features.
DEFINE_BOOL(use_strict, false, "enforce strict mode")
@ -398,23 +373,8 @@ DEFINE_BOOL(future, FUTURE_BOOL,
"Implies all staged features that we want to ship in the "
"not-too-far future")
DEFINE_WEAK_IMPLICATION(future, write_protect_code_memory)
DEFINE_WEAK_IMPLICATION(future, finalize_streaming_on_background)
// Flags for jitless
DEFINE_BOOL(jitless, V8_LITE_BOOL,
"Disable runtime allocation of executable memory.")
// Jitless V8 has a few implications:
DEFINE_NEG_IMPLICATION(jitless, opt)
// Field representation tracking is only used by TurboFan.
DEFINE_NEG_IMPLICATION(jitless, track_field_types)
DEFINE_NEG_IMPLICATION(jitless, track_heap_object_fields)
// Regexps are interpreted.
DEFINE_IMPLICATION(jitless, regexp_interpret_all)
// asm.js validation is disabled since it triggers wasm code generation.
DEFINE_NEG_IMPLICATION(jitless, validate_asm)
// --jitless also implies --no-expose-wasm, see InitializeOncePerProcessImpl.
DEFINE_IMPLICATION(future, write_protect_code_memory)
DEFINE_IMPLICATION(future, finalize_streaming_on_background)
DEFINE_BOOL(assert_types, false,
"generate runtime type assertions to test the typer")
@ -467,6 +427,21 @@ DEFINE_BOOL_READONLY(string_slices, true, "use string slices")
DEFINE_INT(interrupt_budget, 144 * KB,
"interrupt budget which should be used for the profiler counter")
// Flags for jitless
DEFINE_BOOL(jitless, V8_LITE_BOOL,
"Disable runtime allocation of executable memory.")
// Jitless V8 has a few implications:
DEFINE_NEG_IMPLICATION(jitless, opt)
// Field representation tracking is only used by TurboFan.
DEFINE_NEG_IMPLICATION(jitless, track_field_types)
DEFINE_NEG_IMPLICATION(jitless, track_heap_object_fields)
// Regexps are interpreted.
DEFINE_IMPLICATION(jitless, regexp_interpret_all)
// asm.js validation is disabled since it triggers wasm code generation.
DEFINE_NEG_IMPLICATION(jitless, validate_asm)
// --jitless also implies --no-expose-wasm, see InitializeOncePerProcessImpl.
// Flags for inline caching and feedback vectors.
DEFINE_BOOL(use_ic, true, "use inline caching")
DEFINE_INT(budget_for_feedback_vector_allocation, 1 * KB,
@ -539,7 +514,7 @@ DEFINE_BOOL(concurrent_inlining, false,
"run optimizing compiler's inlining phase on a separate thread")
DEFINE_INT(max_serializer_nesting, 25,
"maximum levels for nesting child serializers")
DEFINE_WEAK_IMPLICATION(future, concurrent_inlining)
DEFINE_IMPLICATION(future, concurrent_inlining)
DEFINE_BOOL(trace_heap_broker_verbose, false,
"trace the heap broker verbosely (all reports)")
DEFINE_BOOL(trace_heap_broker_memory, false,
@ -751,7 +726,7 @@ DEFINE_BOOL(liftoff, true,
#else
DEFINE_BOOL(liftoff, false,
"enable Liftoff, the baseline compiler for WebAssembly")
DEFINE_WEAK_IMPLICATION(future, liftoff)
DEFINE_IMPLICATION(future, liftoff)
#endif
// We can't tier up (from Liftoff to TurboFan) in single-threaded mode, hence
// disable Liftoff in that configuration for now. The alternative is disabling
@ -1838,11 +1813,9 @@ DEFINE_IMPLICATION(unbox_double_fields, track_double_fields)
#undef DEFINE_STRING
#undef DEFINE_FLOAT
#undef DEFINE_IMPLICATION
#undef DEFINE_WEAK_IMPLICATION
#undef DEFINE_NEG_IMPLICATION
#undef DEFINE_NEG_VALUE_IMPLICATION
#undef DEFINE_VALUE_IMPLICATION
#undef DEFINE_WEAK_VALUE_IMPLICATION
#undef DEFINE_GENERIC_IMPLICATION
#undef DEFINE_ALIAS_BOOL
#undef DEFINE_ALIAS_INT

334
src/flags/flags.cc
View File

@ -8,11 +8,9 @@
#include <cerrno>
#include <cinttypes>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include "src/base/functional.h"
#include "src/base/logging.h"
#include "src/base/platform/platform.h"
#include "src/codegen/cpu-features.h"
#include "src/logging/counters.h"
@ -35,10 +33,6 @@ namespace internal {
namespace {
struct Flag;
Flag* FindFlagByPointer(const void* ptr);
Flag* FindFlagByName(const char* name);
// This structure represents a single entry in the flag system, with a pointer
// to the actual flag, default value, comment, etc. This is designed to be POD
// initialized as to avoid requiring static constructors.
@ -54,16 +48,12 @@ struct Flag {
TYPE_STRING,
};
enum class SetBy { kDefault, kWeakImplication, kImplication, kCommandLine };
FlagType type_; // What type of flag, bool, int, or string.
const char* name_; // Name of the flag, ex "my_flag".
void* valptr_; // Pointer to the global flag variable.
const void* defptr_; // Pointer to the default value.
const char* cmt_; // A comment about the flags purpose.
bool owns_ptr_; // Does the flag own its string value?
SetBy set_by_ = SetBy::kDefault;
const char* implied_by_ = nullptr;
FlagType type() const { return type_; }
@ -71,90 +61,39 @@ struct Flag {
const char* comment() const { return cmt_; }
bool PointsTo(const void* ptr) const { return valptr_ == ptr; }
bool bool_variable() const {
bool* bool_variable() const {
DCHECK(type_ == TYPE_BOOL);
return *reinterpret_cast<bool*>(valptr_);
return reinterpret_cast<bool*>(valptr_);
}
void set_bool_variable(bool value, SetBy set_by) {
DCHECK(type_ == TYPE_BOOL);
bool change_flag = *reinterpret_cast<bool*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<bool*>(valptr_) = value;
}
MaybeBoolFlag maybe_bool_variable() const {
MaybeBoolFlag* maybe_bool_variable() const {
DCHECK(type_ == TYPE_MAYBE_BOOL);
return *reinterpret_cast<MaybeBoolFlag*>(valptr_);
return reinterpret_cast<MaybeBoolFlag*>(valptr_);
}
void set_maybe_bool_variable(MaybeBoolFlag value, SetBy set_by) {
DCHECK(type_ == TYPE_MAYBE_BOOL);
bool change_flag = *reinterpret_cast<MaybeBoolFlag*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<MaybeBoolFlag*>(valptr_) = value;
}
int int_variable() const {
int* int_variable() const {
DCHECK(type_ == TYPE_INT);
return *reinterpret_cast<int*>(valptr_);
return reinterpret_cast<int*>(valptr_);
}
void set_int_variable(int value, SetBy set_by) {
DCHECK(type_ == TYPE_INT);
bool change_flag = *reinterpret_cast<int*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<int*>(valptr_) = value;
}
unsigned int uint_variable() const {
unsigned int* uint_variable() const {
DCHECK(type_ == TYPE_UINT);
return *reinterpret_cast<unsigned int*>(valptr_);
return reinterpret_cast<unsigned int*>(valptr_);
}
void set_uint_variable(unsigned int value, SetBy set_by) {
DCHECK(type_ == TYPE_UINT);
bool change_flag = *reinterpret_cast<unsigned int*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<unsigned int*>(valptr_) = value;
}
uint64_t uint64_variable() const {
uint64_t* uint64_variable() const {
DCHECK(type_ == TYPE_UINT64);
return *reinterpret_cast<uint64_t*>(valptr_);
return reinterpret_cast<uint64_t*>(valptr_);
}
void set_uint64_variable(uint64_t value, SetBy set_by) {
DCHECK(type_ == TYPE_UINT64);
bool change_flag = *reinterpret_cast<uint64_t*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<uint64_t*>(valptr_) = value;
}
double float_variable() const {
double* float_variable() const {
DCHECK(type_ == TYPE_FLOAT);
return *reinterpret_cast<double*>(valptr_);
return reinterpret_cast<double*>(valptr_);
}
void set_float_variable(double value, SetBy set_by) {
DCHECK(type_ == TYPE_FLOAT);
bool change_flag = *reinterpret_cast<double*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<double*>(valptr_) = value;
}
size_t size_t_variable() const {
size_t* size_t_variable() const {
DCHECK(type_ == TYPE_SIZE_T);
return *reinterpret_cast<size_t*>(valptr_);
}
void set_size_t_variable(size_t value, SetBy set_by) {
DCHECK(type_ == TYPE_SIZE_T);
bool change_flag = *reinterpret_cast<size_t*>(valptr_) != value;
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) *reinterpret_cast<size_t*>(valptr_) = value;
return reinterpret_cast<size_t*>(valptr_);
}
const char* string_value() const {
@ -162,19 +101,12 @@ struct Flag {
return *reinterpret_cast<const char**>(valptr_);
}
void set_string_value(const char* value, bool owns_ptr, SetBy set_by) {
void set_string_value(const char* value, bool owns_ptr) {
DCHECK(type_ == TYPE_STRING);
const char** ptr = reinterpret_cast<const char**>(valptr_);
bool change_flag = (*ptr == nullptr) != (value == nullptr) ||
(*ptr && value && std::strcmp(*ptr, value) != 0);
change_flag = CheckFlagChange(set_by, change_flag);
if (change_flag) {
if (owns_ptr_ && *ptr != nullptr) DeleteArray(*ptr);
*ptr = value;
owns_ptr_ = owns_ptr;
} else {
if (owns_ptr && value != nullptr) DeleteArray(value);
}
if (owns_ptr_ && *ptr != nullptr) DeleteArray(*ptr);
*ptr = value;
owns_ptr_ = owns_ptr;
}
bool bool_default() const {
@ -212,83 +144,23 @@ struct Flag {
return *reinterpret_cast<const char* const*>(defptr_);
}
static bool ShouldCheckFlagContradictions() {
return FLAG_abort_on_contradictory_flags && !FLAG_fuzzing;
}
// {change_flag} indicates if we're going to change the flag value.
// Returns an updated value for {change_flag}, which is changed to false if a
// weak implication is being ignored beause a flag is already set by a normal
// implication or from the command line.
bool CheckFlagChange(SetBy new_set_by, bool change_flag,
const char* implied_by = nullptr) {
if (new_set_by == SetBy::kWeakImplication &&
(set_by_ == SetBy::kImplication || set_by_ == SetBy::kCommandLine)) {
return false;
}
if (ShouldCheckFlagContradictions() && change_flag) {
const char* hint =
"INCOMPATIBLE_FLAGS_PER_VARIANT in "
"tools/testrunner/local/variants.py might be missing a flag for the "
"current variant.";
switch (set_by_) {
case SetBy::kDefault:
break;
case SetBy::kWeakImplication:
if (new_set_by == SetBy::kWeakImplication) {
FATAL(
"Contradictory weak flag implications from --%s and --%s for "
"flag %s\n%s",
implied_by_, implied_by, name(), hint);
}
break;
case SetBy::kImplication:
if (new_set_by == SetBy::kImplication) {
FATAL(
"Contradictory flag implications from --%s and --%s for flag "
"%s\n%s",
implied_by_, implied_by, name(), hint);
}
break;
case SetBy::kCommandLine:
if (new_set_by == SetBy::kImplication) {
FATAL(
"Flag implication from --%s contradicts explicitly provided "
"argument for flag --%s\n%s",
implied_by, name(), hint);
} else if (new_set_by == SetBy::kCommandLine) {
FATAL("Contradictory user-provided values for flag --%s\n%s",
name(), hint);
}
break;
}
}
set_by_ = new_set_by;
if (new_set_by == SetBy::kImplication ||
new_set_by == SetBy::kWeakImplication) {
DCHECK_NOT_NULL(implied_by);
implied_by_ = implied_by;
}
return change_flag;
}
// Compare this flag's current value against the default.
bool IsDefault() const {
switch (type_) {
case TYPE_BOOL:
return bool_variable() == bool_default();
return *bool_variable() == bool_default();
case TYPE_MAYBE_BOOL:
return maybe_bool_variable().has_value == false;
return maybe_bool_variable()->has_value == false;
case TYPE_INT:
return int_variable() == int_default();
return *int_variable() == int_default();
case TYPE_UINT:
return uint_variable() == uint_default();
return *uint_variable() == uint_default();
case TYPE_UINT64:
return uint64_variable() == uint64_default();
return *uint64_variable() == uint64_default();
case TYPE_FLOAT:
return float_variable() == float_default();
return *float_variable() == float_default();
case TYPE_SIZE_T:
return size_t_variable() == size_t_default();
return *size_t_variable() == size_t_default();
case TYPE_STRING: {
const char* str1 = string_value();
const char* str2 = string_default();
@ -304,34 +176,31 @@ struct Flag {
void Reset() {
switch (type_) {
case TYPE_BOOL:
set_bool_variable(bool_default(), SetBy::kDefault);
*bool_variable() = bool_default();
break;
case TYPE_MAYBE_BOOL:
set_maybe_bool_variable(MaybeBoolFlag::Create(false, false),
SetBy::kDefault);
*maybe_bool_variable() = MaybeBoolFlag::Create(false, false);
break;
case TYPE_INT:
set_int_variable(int_default(), SetBy::kDefault);
*int_variable() = int_default();
break;
case TYPE_UINT:
set_uint_variable(uint_default(), SetBy::kDefault);
*uint_variable() = uint_default();
break;
case TYPE_UINT64:
set_uint64_variable(uint64_default(), SetBy::kDefault);
*uint64_variable() = uint64_default();
break;
case TYPE_FLOAT:
set_float_variable(float_default(), SetBy::kDefault);
*float_variable() = float_default();
break;
case TYPE_SIZE_T:
set_size_t_variable(size_t_default(), SetBy::kDefault);
*size_t_variable() = size_t_default();
break;
case TYPE_STRING:
set_string_value(string_default(), false, SetBy::kDefault);
set_string_value(string_default(), false);
break;
}
}
void AllowOverwriting() { set_by_ = SetBy::kDefault; }
};
Flag flags[] = {
@ -341,31 +210,6 @@ Flag flags[] = {
const size_t num_flags = sizeof(flags) / sizeof(*flags);
inline char NormalizeChar(char ch) { return ch == '_' ? '-' : ch; }
bool EqualNames(const char* a, const char* b) {
for (int i = 0; NormalizeChar(a[i]) == NormalizeChar(b[i]); i++) {
if (a[i] == '\0') {
return true;
}
}
return false;
}
Flag* FindFlagByName(const char* name) {
for (size_t i = 0; i < num_flags; ++i) {
if (EqualNames(name, flags[i].name())) return &flags[i];
}
return nullptr;
}
Flag* FindFlagByPointer(const void* ptr) {
for (size_t i = 0; i < num_flags; ++i) {
if (flags[i].PointsTo(ptr)) return &flags[i];
}
return nullptr;
}
} // namespace
static const char* Type2String(Flag::FlagType type) {
@ -393,27 +237,27 @@ static const char* Type2String(Flag::FlagType type) {
std::ostream& operator<<(std::ostream& os, const Flag& flag) { // NOLINT
switch (flag.type()) {
case Flag::TYPE_BOOL:
os << (flag.bool_variable() ? "true" : "false");
os << (*flag.bool_variable() ? "true" : "false");
break;
case Flag::TYPE_MAYBE_BOOL:
os << (flag.maybe_bool_variable().has_value
? (flag.maybe_bool_variable().value ? "true" : "false")
os << (flag.maybe_bool_variable()->has_value
? (flag.maybe_bool_variable()->value ? "true" : "false")
: "unset");
break;
case Flag::TYPE_INT:
os << flag.int_variable();
os << *flag.int_variable();
break;
case Flag::TYPE_UINT:
os << flag.uint_variable();
os << *flag.uint_variable();
break;
case Flag::TYPE_UINT64:
os << flag.uint64_variable();
os << *flag.uint64_variable();
break;
case Flag::TYPE_FLOAT:
os << flag.float_variable();
os << *flag.float_variable();
break;
case Flag::TYPE_SIZE_T:
os << flag.size_t_variable();
os << *flag.size_t_variable();
break;
case Flag::TYPE_STRING: {
const char* str = flag.string_value();
@ -431,7 +275,7 @@ std::vector<const char*>* FlagList::argv() {
Flag* f = &flags[i];
if (!f->IsDefault()) {
{
bool disabled = f->type() == Flag::TYPE_BOOL && !f->bool_variable();
bool disabled = f->type() == Flag::TYPE_BOOL && !*f->bool_variable();
std::ostringstream os;
os << (disabled ? "--no" : "--") << f->name();
args->push_back(StrDup(os.str().c_str()));
@ -446,6 +290,8 @@ std::vector<const char*>* FlagList::argv() {
return args;
}
inline char NormalizeChar(char ch) { return ch == '_' ? '-' : ch; }
// Helper function to parse flags: Takes an argument arg and splits it into
// a flag name and flag value (or nullptr if they are missing). negated is set
// if the arg started with "-no" or "--no". The buffer may be used to NUL-
@ -488,6 +334,22 @@ static void SplitArgument(const char* arg, char* buffer, int buffer_size,
}
}
static bool EqualNames(const char* a, const char* b) {
for (int i = 0; NormalizeChar(a[i]) == NormalizeChar(b[i]); i++) {
if (a[i] == '\0') {
return true;
}
}
return false;
}
static Flag* FindFlag(const char* name) {
for (size_t i = 0; i < num_flags; ++i) {
if (EqualNames(name, flags[i].name())) return &flags[i];
}
return nullptr;
}
template <typename T>
bool TryParseUnsigned(Flag* flag, const char* arg, const char* value,
char** endp, T* out_val) {
@ -526,7 +388,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, char** argv,
if (name != nullptr) {
// lookup the flag
Flag* flag = FindFlagByName(name);
Flag* flag = FindFlag(name);
if (flag == nullptr) {
if (remove_flags) {
// We don't recognize this flag but since we're removing
@ -559,50 +421,37 @@ int FlagList::SetFlagsFromCommandLine(int* argc, char** argv,
char* endp = const_cast<char*>(""); // *endp is only read
switch (flag->type()) {
case Flag::TYPE_BOOL:
flag->set_bool_variable(!negated, Flag::SetBy::kCommandLine);
*flag->bool_variable() = !negated;
break;
case Flag::TYPE_MAYBE_BOOL:
flag->set_maybe_bool_variable(MaybeBoolFlag::Create(true, !negated),
Flag::SetBy::kCommandLine);
*flag->maybe_bool_variable() = MaybeBoolFlag::Create(true, !negated);
break;
case Flag::TYPE_INT:
flag->set_int_variable(static_cast<int>(strtol(value, &endp, 10)),
Flag::SetBy::kCommandLine);
*flag->int_variable() = static_cast<int>(strtol(value, &endp, 10));
break;
case Flag::TYPE_UINT: {
unsigned int parsed_value;
if (TryParseUnsigned(flag, arg, value, &endp, &parsed_value)) {
flag->set_uint_variable(parsed_value, Flag::SetBy::kCommandLine);
} else {
case Flag::TYPE_UINT:
if (!TryParseUnsigned(flag, arg, value, &endp,
flag->uint_variable())) {
return_code = j;
}
break;
}
case Flag::TYPE_UINT64: {
uint64_t parsed_value;
if (TryParseUnsigned(flag, arg, value, &endp, &parsed_value)) {
flag->set_uint64_variable(parsed_value, Flag::SetBy::kCommandLine);
} else {
case Flag::TYPE_UINT64:
if (!TryParseUnsigned(flag, arg, value, &endp,
flag->uint64_variable())) {
return_code = j;
}
break;
}
case Flag::TYPE_FLOAT:
flag->set_float_variable(strtod(value, &endp),
Flag::SetBy::kCommandLine);
*flag->float_variable() = strtod(value, &endp);
break;
case Flag::TYPE_SIZE_T: {
size_t parsed_value;
if (TryParseUnsigned(flag, arg, value, &endp, &parsed_value)) {
flag->set_size_t_variable(parsed_value, Flag::SetBy::kCommandLine);
} else {
case Flag::TYPE_SIZE_T:
if (!TryParseUnsigned(flag, arg, value, &endp,
flag->size_t_variable())) {
return_code = j;
}
break;
}
case Flag::TYPE_STRING:
flag->set_string_value(value ? StrDup(value) : nullptr, true,
Flag::SetBy::kCommandLine);
flag->set_string_value(value ? StrDup(value) : nullptr, true);
break;
}
@ -741,8 +590,6 @@ void FlagList::PrintHelp() {
}
}
namespace {
static uint32_t flag_hash = 0;
void ComputeFlagListHash() {
@ -755,7 +602,8 @@ void ComputeFlagListHash() {
}
for (size_t i = 0; i < num_flags; ++i) {
Flag* current = &flags[i];
if (current->PointsTo(&FLAG_profile_deserialization)) {
if (current->type() == Flag::TYPE_BOOL &&
current->bool_variable() == &FLAG_profile_deserialization) {
// We want to be able to flip --profile-deserialization without
// causing the code cache to get invalidated by this hash.
continue;
@ -770,39 +618,11 @@ void ComputeFlagListHash() {
base::hash_range(args.c_str(), args.c_str() + args.length()));
}
template <class T>
struct Identity {
using type = T;
};
template <class A>
bool TriggerImplication(bool premise, const char* premise_name,
A* conclusion_pointer, typename Identity<A>::type value,
bool weak_implication) {
if (premise) {
bool change_flag = *conclusion_pointer != value;
Flag* conclusion_flag = FindFlagByPointer(conclusion_pointer);
change_flag = conclusion_flag->CheckFlagChange(
weak_implication ? Flag::SetBy::kWeakImplication
: Flag::SetBy::kImplication,
change_flag, premise_name);
if (change_flag) *conclusion_pointer = value;
return change_flag;
}
return false;
}
} // namespace
// static
void FlagList::EnforceFlagImplications() {
bool changed;
do {
changed = false;
#define FLAG_MODE_DEFINE_IMPLICATIONS
#include "src/flags/flag-definitions.h" // NOLINT(build/include)
#undef FLAG_MODE_DEFINE_IMPLICATIONS
} while (changed);
ComputeFlagListHash();
}

1
test/inspector/inspector-test.cc
View File

@ -1056,7 +1056,6 @@ int main(int argc, char* argv[]) {
v8::V8::InitializeICUDefaultLocation(argv[0]);
std::unique_ptr<v8::Platform> platform(v8::platform::NewDefaultPlatform());
v8::V8::InitializePlatform(platform.get());
v8::internal::FLAG_abort_on_contradictory_flags = true;
v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
v8::V8::InitializeExternalStartupData(argv[0]);
v8::V8::Initialize();

2
test/message/wasm-trace-memory-liftoff.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --no-stress-opt --trace-wasm-memory --liftoff
// Flags: --no-stress-opt --trace-wasm-memory --liftoff --no-future
// Flags: --no-wasm-tier-up --experimental-wasm-simd
// Flags: --enable-sse3 --enable-sse4-1

2
test/message/wasm-trace-memory.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --no-stress-opt --trace-wasm-memory --no-liftoff
// Flags: --no-stress-opt --trace-wasm-memory --no-liftoff --no-future
// Flags: --experimental-wasm-simd
load("test/mjsunit/wasm/wasm-module-builder.js");

11
test/mjsunit/ensure-growing-store-learns.js
View File

@ -2,15 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// The flags are processed left to right. --no-abort-on-contradictory-flags
// disables the checking for conflicts, then we process --noverify-heap and
// --noenable-slow-asserts, which the test runner already set to true before.
// This causes the flags to be overwritten while silencing the error. Then we
// re-enable --abort-on-contradictory-flags to make sure that the processing of
// other flags and flag implications, which happens later, still produces
// errors.
// Flags: --no-abort-on-contradictory-flags --noverify-heap --noenable-slow-asserts --abort-on-contradictory-flags
// Flags: --allow-natives-syntax --opt --no-always-opt
// Flags: --allow-natives-syntax --noverify-heap --noenable-slow-asserts
// Flags: --opt --no-always-opt
// --noverify-heap and --noenable-slow-asserts are set because the test is too
// slow with it on.

15
test/mjsunit/mjsunit.status
View File

@ -367,6 +367,17 @@
'regexp-tier-up-multiple': [SKIP],
'regress/regress-996234': [SKIP],
# Tests that depend on optimization (beyond doing assertOptimized).
'compiler/is-being-interpreted-*': [SKIP],
'compiler/serializer-accessors': [SKIP],
'compiler/serializer-apply': [SKIP],
'compiler/serializer-call': [SKIP],
'compiler/serializer-dead-after-jump': [SKIP],
'compiler/serializer-dead-after-return': [SKIP],
'compiler/serializer-transition-propagation': [SKIP],
'regress/regress-1049982-1': [SKIP],
'regress/regress-1049982-2': [SKIP],
# These tests check that we can trace the compiler.
'tools/compiler-trace-flags': [SKIP],
'tools/compiler-trace-flags-wasm': [SKIP],
@ -1142,6 +1153,10 @@
'regress/regress-1049982-2': [SKIP],
'es6/iterator-eager-deopt': [SKIP],
# interrupt_budget overrides don't work with TurboProp.
'interrupt-budget-override': [SKIP],
'never-optimize': [SKIP],
# In turboprop we reuse the optimized code on soft deopt. The following tests
# test for a soft deopt and they won't work in TurboProp.
'deopt-recursive-soft-once': [SKIP],

10
test/mjsunit/random-bit-correlations.js
View File

@ -2,15 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Overwrite the random seed provided by the test runner to make this test less
// flaky.
// The flags are processed left to right. --no-abort-on-contradictory-flags
// disables the checking for conflicts, then we process --random-seed=20 to
// overwrite the value the test runner already set before. Then we re-enable
// --abort-on-contradictory-flags to make sure that the processing of other
// flags and flag implications, which happens later, still produces errors.
// Flags: --no-abort-on-contradictory-flags --random-seed=20 --abort-on-contradictory-flags
// Flags: --nostress-opt --noalways-opt --predictable
// Flags: --random-seed=20 --nostress-opt --noalways-opt --predictable
(function() {
var kHistory = 2;

2
test/mjsunit/regress/regress-356053.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --expose-gc --allow-natives-syntax
// Flags: --noconcurrent-recompilation --expose-gc --allow-natives-syntax
// Flags: --concurrent-recompilation --block-concurrent-recompilation
gc();

2
test/mjsunit/regress/regress-411210.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax --gc-interval=439
// Flags: --allow-natives-syntax --gc-interval=439 --random-seed=-423594851
var __v_3;
function __f_2() {

2
test/mjsunit/regress/regress-487981.js
View File

@ -4,7 +4,7 @@
// Flags: --allow-natives-syntax --stress-compaction
// To reliably reproduce the crash use --verify-heap
// To reliably reproduce the crash use --verify-heap --random-seed=-133185440
function __f_2(o) {
return o.field.b.x;

2
test/mjsunit/regress/regress-8265.js
View File

@ -2,6 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --random-seed=1
for (let i = 0; i < 54; ++i) Math.random();
let sum = 0;
for (let i = 0; i < 10; ++i)

2
test/mjsunit/regress/regress-863810.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --no-liftoff --debug-code
// Flags: --no-liftoff --no-future --debug-code
load('test/mjsunit/wasm/wasm-module-builder.js');

2
test/mjsunit/regress/regress-883059.js
View File

@ -2,6 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --disable-in-process-stack-traces --no-lazy
// Flags: --random-seed=-1595876594 --disable-in-process-stack-traces --no-lazy
var __v_47 = ({[__v_46]: __f_52}) => { var __v_46 = 'b'; return __f_52; };

2
test/mjsunit/regress/regress-crbug-664506.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --expose-gc --predictable
// Flags: --expose-gc --predictable --random-seed=-1109634722
gc();
gc();

2
test/mjsunit/regress/wasm/regress-02256.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Flags: --expose-gc --allow-natives-syntax
// Flags: --random-seed=891196975 --expose-gc --allow-natives-syntax
// Flags: --gc-interval=207 --stress-compaction --validate-asm
// Flags: --opt --no-always-opt
//

5
test/mjsunit/regress/wasm/regress-02256b.js
View File

@ -2,8 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Flags: --expose-gc --allow-natives-syntax --gc-interval=207
// Flags: --stress-compaction --validate-asm --opt --no-always-opt
// Flags: --random-seed=891196975 --expose-gc --allow-natives-syntax
// Flags: --gc-interval=207 --stress-compaction --validate-asm
// Flags: --opt --no-always-opt
//
// /v8/test/mjsunit/wasm/grow-memory.js
// /v8/test/mjsunit/regress/regress-540.js

2
test/mjsunit/regress/wasm/regress-02862.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --expose-gc --invoke-weak-callbacks --omit-quit --gc-interval=469 --validate-asm
// Flags: --random-seed=1557792826 --expose-gc --invoke-weak-callbacks --omit-quit --gc-interval=469 --validate-asm
function nop() {}
var __v_42 = {};

2
test/mjsunit/regress/wasm/regress-666741.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Flags: --enable-slow-asserts --expose-wasm
// Flags: --random-seed=-1101427159 --enable-slow-asserts --expose-wasm
(function __f_7() {
assertThrows(() => new WebAssembly.Memory({initial: 59199}), RangeError);

3
test/mjsunit/string-case.js
View File

@ -25,7 +25,8 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --allow-natives-syntax --expose-externalize-string
// Flags: --random-seed=17 --allow-natives-syntax
// Flags: --expose-externalize-string
assertEquals("ΚΟΣΜΟΣ ΚΟΣΜΟΣ".toLowerCase(), "κοσμος κοσμος");

2
test/mjsunit/wasm/tier-up-testing-flag.js
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax --liftoff --no-wasm-tier-up
// Flags: --allow-natives-syntax --liftoff --no-future --no-wasm-tier-up
// Compile functions 0 and 2 with Turbofan, the rest with Liftoff:
// Flags: --wasm-tier-mask-for-testing=5

18
tools/testrunner/local/variants.py
View File

@ -24,7 +24,8 @@ ALL_VARIANT_FLAGS = {
# independent of JS optimizations, so we can combine those configs.
"nooptimization": [["--no-opt", "--liftoff", "--no-wasm-tier-up"]],
"slow_path": [["--force-slow-path"]],
"stress": [["--stress-opt", "--no-liftoff", "--stress-lazy-source-positions"]],
"stress": [["--stress-opt", "--always-opt", "--no-liftoff",
"--stress-lazy-source-positions"]],
"stress_js_bg_compile_wasm_code_gc": [["--stress-background-compile",
"--stress-wasm-code-gc"]],
"stress_incremental_marking": [["--stress-incremental-marking"]],
@ -39,21 +40,6 @@ ALL_VARIANT_FLAGS = {
"top_level_await": [["--harmony-top-level-await"]],
}
# Flags that lead to a contradiction with the flags provided by the respective
# variant. This depends on the flags specified in ALL_VARIANT_FLAGS and on the
# implications defined in flag-definitions.h
INCOMPATIBLE_FLAGS_PER_VARIANT = {
"assert_types": ["--no-assert-types"],
"jitless": ["--opt", "--liftoff", "--track-field-types", "--validate-asm"],
"no_wasm_traps": ["--wasm-trap-handler"],
"nooptimization": ["--opt", "--no-liftoff", "--predictable", "--wasm-tier-up"],
"slow_path": ["--no-force-slow-path"],
"stress_incremental_marking": ["--no-stress-incremental-marking"],
"stress_js_bg_compile_wasm_code_gc": ["--no-stress-background-compile"],
"stress": ["--always-opt", "--liftoff"],
"turboprop": ["--turbo-inlining", "--interrupt-budget=*", "--no-turboprop"],
}
SLOW_VARIANTS = set([
'stress',
'stress_snapshot',

30
tools/testrunner/objects/testcase.py
View File

@ -34,7 +34,6 @@ from ..outproc import base as outproc
from ..local import command
from ..local import statusfile
from ..local import utils
from ..local.variants import INCOMPATIBLE_FLAGS_PER_VARIANT
FLAGS_PATTERN = re.compile(r"//\s+Flags:(.*)")
@ -85,8 +84,7 @@ class TestCase(object):
# Outcomes
self._statusfile_outcomes = None
self._expected_outcomes = None
self._checked_flag_contradictions = False
self.expected_outcomes = None
self._statusfile_flags = None
self._prepare_outcomes()
@ -118,7 +116,7 @@ class TestCase(object):
outcomes = self.suite.statusfile.get_outcomes(self.name, self.variant)
self._statusfile_outcomes = filter(not_flag, outcomes)
self._statusfile_flags = filter(is_flag, outcomes)
self._expected_outcomes = (
self.expected_outcomes = (
self._parse_status_file_outcomes(self._statusfile_outcomes))
def _parse_status_file_outcomes(self, outcomes):
@ -143,30 +141,6 @@ class TestCase(object):
return outproc.OUTCOMES_FAIL
return expected_outcomes or outproc.OUTCOMES_PASS
@property
def expected_outcomes(self):
if not self._checked_flag_contradictions:
self._checked_flag_contradictions = True
def normalize_flag(flag):
return flag.replace("_", "-").replace("--no-", "--no")
all_flags = [normalize_flag(flag) for flag in self._get_cmd_params()]
def has_flag(conflicting_flag):
conflicting_flag = normalize_flag(conflicting_flag)
if conflicting_flag in all_flags:
return True
if conflicting_flag.endswith("*"):
return any(flag.startswith(conflicting_flag[:-1]) for flag in all_flags)
return False
if self.variant in INCOMPATIBLE_FLAGS_PER_VARIANT:
for conflicting_flag in INCOMPATIBLE_FLAGS_PER_VARIANT[self.variant]:
if has_flag(conflicting_flag):
self._expected_outcomes = outproc.OUTCOMES_FAIL
return self._expected_outcomes
@property
def do_skip(self):
return (statusfile.SKIP in self._statusfile_outcomes and