grepping through v8 for comments that have "anyway" in them

gistfile1.txt

zone/zone-list.h:  // zone-allocated objects for which destructors are not called anyway, so
ast/scopes.cc:    // scope and we terminate the iteration there anyway.
ast/scopes.cc:  // in the outer scope anyway, because if a binding exists in an outer
ast/scopes.h:    // Sloppy eval in script scopes can only introduce global variables anyway,
ast/scopes.h:      //      isn't extendable anyway, or
heap/memory-chunk.cc:    // Not actually used but initialize anyway for predictability.
heap/cppgc/heap-page.cc:  //    for the first header which will anyways serve as header again.
heap/heap.cc:    // This is an optimization. The sweeper will release black fillers anyway.
codegen/x64/assembler-x64.cc:  // (larger) kCodeAlignment anyways.
codegen/ia32/assembler-ia32.cc:  // (larger) kCodeAlignment anyways.
codegen/s390/macro-assembler-s390.cc:    // return anyway.
codegen/s390/assembler-s390.cc:  // (larger) kCodeAlignment anyways.
codegen/mips64/macro-assembler-mips64.cc:  // This is not an issue, t9 is expected to be clobbered anyway.
codegen/mips64/assembler-mips64.cc:  // (larger) kCodeAlignment anyways.
codegen/loong64/assembler-loong64.cc:  // (larger) kCodeAlignment anyways.
codegen/ppc/assembler-ppc.cc:  // (larger) kCodeAlignment anyways.
codegen/arm64/macro-assembler-arm64.cc:  // in most cases anyway, so this restriction shouldn't be too serious.
codegen/arm64/assembler-arm64.cc:  // (larger) kCodeAlignment anyways.
codegen/code-stub-assembler.cc:  // The empty fixed array is not modifiable anyway. And we shouldn't change its
codegen/code-stub-assembler.cc:  // next GC, and allocation sites are designed to survive several GCs anyway.
codegen/riscv64/assembler-riscv64.cc:  // (larger) kCodeAlignment anyways.
codegen/arm/assembler-arm.cc:  // (larger) kCodeAlignment anyways.
codegen/arm/macro-assembler-arm.cc:    // return anyway.
codegen/mips/macro-assembler-mips.cc:  // This is not an issue, t9 is expected to be clobbered anyway.
codegen/mips/assembler-mips.cc:  // (larger) kCodeAlignment anyways.
snapshot/serializer.cc:    // references to the not_mapped_symbol anyway, so it's fine.
snapshot/context-serializer.cc:    // serialize optimized code anyway.
web-snapshot/web-snapshot.cc:// secure way. We cannot trust the data anyway, so every upcoming byte can have
interpreter/bytecode-array-builder.cc:  // anyway.
parsing/expression-scope.h:        // without initializer, but that's unlikely anyway.
parsing/rewriter.cc:  // will be overwritten anyway. This is a bit more tricky than what I
parsing/parser.cc:    // length until we have decoded it anyway even if we knew the raw data
parsing/parser-base.h:    // If next token is not `=>`, it's a syntax error anyways.
wasm/jump-table-assembler.h:  // must be independent of the code range of any isolate anyway. Just ensure
wasm/baseline/ia32/liftoff-assembler-ia32.h:    // of {dst}, hence overwritten anyway), move {ecx} to a tmp register and
wasm/baseline/liftoff-assembler.cc:  // into registers since we need to load the value anyways.
wasm/baseline/liftoff-compiler.cc:    // be rare anyway.
wasm/baseline/liftoff-compiler.cc:    // cannot be used as immediate value anyway, so we can also just put them in
wasm/baseline/liftoff-compiler.cc:  // least {AssemblerBase::kMinimalBufferSize} anyway, so in the worst case we
wasm/function-body-decoder-impl.h:        // were also inserted, disregard them, as they will be dropped anyway.
wasm/module-decoder.cc:          // custom section anyways.
wasm/module-decoder.cc:          // custom section anyways.
wasm/decoder.h:  // anyway.
wasm/wasm-external-refs.cc:  //   less or equal to 25 bits, the uint64 to float32 conversion is anyways
wasm/wasm-engine.cc:    // ref count is not needed, since the {NativeModule} dies anyway.
wasm/wasm-serialization.cc:    // Publishing is sequential anyway, so never return more than 1. If a
wasm/wasm-objects.h:  // property lookup anyway.)
wasm/wasm-code-manager.cc:      // small modules will never trigger GC anyway.
regexp/regexp-macro-assembler.cc:  // thread might do allocation anyway.
regexp/regexp-macro-assembler.cc:    // {input_end}, we are about to return anyway.
regexp/regexp-compiler.cc:  // Omit flushing the trace. We discard the entire stack frame anyway.
regexp/experimental/experimental-interpreter.cc:        // We abort the interpreter now anyway, so gc can't invalidate any
regexp/regexp-bytecode-generator.h:  // The byte-code interpreter checks on each push anyway.
d8/d8-platforms.cc:      // delay here anyway.
d8/d8.cc:    // We use mmap, which initializes pages to zero anyway.
base/platform/platform-posix.cc:  // work on 64-bit platforms, but Cygwin doesn't support 64-bit anyway.
base/platform/platform-win32.cc:  // don't have viable ASLR anyway.
base/numbers/bignum-dtoa.cc:    // Note that it should not have any effect anyways since the string is
base/numbers/bignum-dtoa.cc:    // Note that it should not have any effect anyways since the string is
base/bounded-page-allocator.cc:    // allocate there since any extra space couldn't be used anyway.
base/template-utils.h:// disallowed by the style guide anyway).
base/optional.h:// behavior, but anyway it reports an error, too.
builtins/builtins-object-gen.cc:  // immediately aborts and returns false anyways.
builtins/base.tq:// anyway and throw a RangeError in case of out-of-bounds index.
builtins/builtins-array-gen.cc:    // return 'not equal' for holes anyway.
builtins/builtins-array-gen.cc:    // produce values again anyways.
builtins/builtins-regexp-gen.cc:  // anyway, consider using UintPtrT index to simplify the code below.
builtins/ia32/builtins-ia32.cc:  // No need to pop eax here since we will be aborting anyway.
builtins/promise-all.tq:        // Promises anyway.
builtins/arm64/builtins-arm64.cc:  // which can push arbitrary data onto the stack anyway, and so the GC won't
builtins/promise-misc.tq:  // Proxy object, which would throw when it is called anyway. So instead of
builtins/builtins-string.cc:  // assuming non-empty chunks they would generate too-long strings anyway.
builtins/builtins-microtask-queue-gen.cc:    // of CallHandlerTasks (which is not a realistic use case anyways).
builtins/promise-any.tq:        // anyway.
builtins/typed-array-createtypedarray.tq:    // than our 32-bit arithmetic range anyway. 64 bit platforms could
builtins/typed-array-createtypedarray.tq:    // anyway.
objects/js-objects.cc:    // impossible to make any assumptions about the prototype chain anyway.
objects/literal-objects.cc:  // avoid creation of closures that will be overwritten anyway.
objects/js-objects-inl.h:  // kSystemPointerSize) anyway.
objects/code.cc:  // updated by the gc, but that's ok because we've disallowed GCs anyway.
objects/js-array-buffer.cc:    // anyway.
objects/bigint.cc:        // "& 63" to appease compilers. kDigitBits is 32 here anyway.
objects/objects.cc:        // anyways.
objects/objects.cc:    // 15b. Let newWritable be false. (It's initialized as "false" anyway.)
objects/map-updater.cc:      // the NowIs check below would fail anyway in that case.
objects/templates.h:  // a limit on it anyway to not crash for embedders that re-create templates
execution/frames.cc:      // The frame anyways will be skipped.
security/vm-cage.cc:    // PA anyway uses MAP_JIT for V8 mappings. Further, we want to eventually
diagnostics/perf-jit.cc:  // which is the only platform supported for --perf-prof anyway.
profiler/sampling-heap-profiler.cc:    // sensitive moment belong to the formerly optimized frame anyway.
runtime/runtime-regexp.cc:  // length of a string, i.e. it is always a Smi.  We check anyway for security.
runtime/runtime-regexp.cc:  // length of a string, i.e. it is always a Smi.  We check anyway for security.
init/bootstrapper.cc:  // will be internalized during property addition anyway, so do it here now.
init/bootstrapper.cc:    // JavaScript anyways.
ic/accessor-assembler.cc:  // single entry in the {feedback} array anyways.
ic/accessor-assembler.cc:      // but they are not expected here anyway.
ic/accessor-assembler.cc:      // but they are not expected here anyway.
compiler/pipeline.cc:  // because we cannot compute meaningful types anyways, and the computed types
compiler/pipeline.cc:  // because we cannot compute meaningful types anyways, and the computed types
compiler/backend/x64/code-generator-x64.cc:      // Use rcx as a scratch register, we return anyways immediately.
compiler/backend/x64/code-generator-x64.cc:        // We push it anyway to satisfy legacy assumptions about these frames'
compiler/backend/x64/instruction-selector-x64.cc:      // 32 bits anyway.
compiler/backend/x64/instruction-selector-x64.cc:        // handle them here anyways.
compiler/backend/x64/instruction-selector-x64.cc:        // usually only happens in dead code anyway.
compiler/backend/code-generator.cc:      // knowledge about those fields anyway.
compiler/backend/ia32/code-generator-ia32.cc:        // Use ecx as a scratch register, we return anyways immediately.
compiler/backend/mips64/instruction-selector-mips64.cc:    // 32 bits anyway.
compiler/backend/instruction.h:// align the object to 8 bytes anyway (covered by a static assert below).
compiler/backend/loong64/instruction-selector-loong64.cc:    // 32 bits anyway.
compiler/backend/arm64/instruction-selector-arm64.cc:    // 32 bits anyway.
compiler/backend/instruction-selector.cc:      // register. If we have a constant, we use a register anyway to simplify
compiler/backend/riscv64/instruction-selector-riscv64.cc:    // 32 bits anyway.
compiler/backend/mid-tier-register-allocator.cc:              // for this gap move. It would be spilled anyway since it contains
compiler/backend/mid-tier-register-allocator.cc:  //    definition point, since it is more likely to be spilled anyway.
compiler/backend/register-allocator.cc:        // the same outcome anyway.
compiler/backend/register-allocator.cc:      // interesting to this range anyway.
compiler/backend/register-allocator.cc:      // anyway. While this is an optimization, the code in LiveRangeConnector
compiler/redundancy-elimination.cc:  // because we will have to recompute anyway once we compute the predecessor.
compiler/redundancy-elimination.cc:  // because we will have to recompute anyway once we compute the predecessor.
compiler/redundancy-elimination.cc:  // because we will have to recompute anyway once we compute the predecessor.
compiler/redundancy-elimination.cc:  // because we will have to recompute anyway once we compute the predecessor.
compiler/basic-block-instrumentor.cc:  // it and entry into it means falling off the end of the function anyway.
compiler/int64-lowering.cc:          // representation anyway.
compiler/int64-lowering.cc:        // the shift can only be between 0 and 63 anyways.
compiler/int64-lowering.cc:        // the shift can only be between 0 and 63 anyways.
compiler/int64-lowering.cc:        // the shift can only be between 0 and 63 anyways.
compiler/simplified-lowering.cc:      // right hand side doesn't matter anyways, so in particular there's
compiler/simplified-lowering.cc:    // right hand side doesn't matter anyways, so in particular there's
compiler/simplified-lowering.cc:        // right hand side doesn't matter anyways, so in particular there's
compiler/simplified-lowering.cc:        // -0, since both of them are mapped to false anyways, so we
compiler/js-native-context-specialization.cc:  // [[Get]] operation does an implicit ToObject anyway, and these operations
compiler/operation-typer.cc:  // contribute to the resulting type anyways.
compiler/branch-elimination.cc:  // yet because we will have to recompute anyway once we compute the
compiler/branch-elimination.cc:  // yet because we will have to recompute anyway once we compute the
compiler/branch-elimination.cc:  // yet because we will have to recompute anyway once we compute the
compiler/load-elimination.cc:      // just yet because we will have to recompute anyway once we compute
compiler/heap-refs.cc:  // method should go away anyway once the compiler is fully concurrent.
compiler/representation-change.h:    // type BigInt anyway.
compiler/effect-control-linearizer.cc:    // But in this case, we'll deopt anyway because of the following checks.
compiler/effect-control-linearizer.cc:      // else it cannot match the recorded feedback {exp} anyways.
compiler/effect-control-linearizer.cc:      // to copy anything anyway.
compiler/escape-analysis.cc:          // later anyway.
compiler/csa-load-elimination.cc:    // yet because we will have to recompute anyway once we compute the
compiler/js-call-reducer.cc:  // Object.prototype.hasOwnProperty does an implicit ToObject anyway, and
compiler/js-call-reducer.cc:  // if we anyways have to load it (to reduce register pressure).
compiler/wasm-compiler.cc:      // We need an instance node anyway, because FromJS() needs to pass it to
compiler/wasm-compiler.cc:      // Class constructor will throw anyway.
compiler/js-create-lowering.cc:        // pruned anyway.
compiler/js-create-lowering.cc:        // pruned anyway.
compiler/js-create-lowering.cc:        // pruned anyway.
compiler/js-create-lowering.cc:      // it will get overwritten anyways and the store's MachineType (AnyTagged)
api/api-natives.cc:// return the same getter or setter. However, objects will be cloned anyways,
bigint/bitwise.cc:  // Any leftover borrows don't matter, the '&' would drop them anyway.
bigint/fromstring.cc://   as the parts/multipliers grow, we'll need most of the memory anyway.)