Changeset 221954 in webkit for trunk/Source/JavaScriptCore/b3


Ignore:
Timestamp:
Sep 12, 2017, 6:31:07 PM (8 years ago)
Author:
[email protected]
Message:

Do unified source builds for JSC
​https://bugs.webkit.org/show_bug.cgi?id=176076

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

This patch switches the CMake JavaScriptCore build to use unified sources.
The Xcode build will be upgraded in a follow up patch.

Most of the source changes in this patch are fixing static
variable/functions name collisions. The most common collisions
were from our use of "static const bool verbose" and "using
namespace ...". I fixed all the verbose cases and fixed the "using
namespace" issues that occurred under the current bundling
strategy. It's likely that more of the "using namespace" issues
will need to be resolved in the future, particularly in the FTL.

I don't expect either of these problems will apply to other parts
of the project nearly as much as in JSC. Using a verbose variable
is a JSC idiom and JSC tends use the same, canonical, class name
in multiple parts of the engine.

  • CMakeLists.txt:
  • b3/B3CheckSpecial.cpp:

(JSC::B3::CheckSpecial::forEachArg):
(JSC::B3::CheckSpecial::generate):
(JSC::B3::Air::numB3Args): Deleted.

  • b3/B3DuplicateTails.cpp:
  • b3/B3EliminateCommonSubexpressions.cpp:
  • b3/B3FixSSA.cpp:

(JSC::B3::demoteValues):

  • b3/B3FoldPathConstants.cpp:
  • b3/B3InferSwitches.cpp:
  • b3/B3LowerMacrosAfterOptimizations.cpp:

(): Deleted.

  • b3/B3LowerToAir.cpp:

(JSC::B3::Air::LowerToAir::LowerToAir): Deleted.
(JSC::B3::Air::LowerToAir::run): Deleted.
(JSC::B3::Air::LowerToAir::shouldCopyPropagate): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::ArgPromise): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::swap): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::operator=): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::~ArgPromise): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::setTraps): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::tmp): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::operator bool const): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::kind const): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::peek const): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::consume): Deleted.
(JSC::B3::Air::LowerToAir::ArgPromise::inst): Deleted.
(JSC::B3::Air::LowerToAir::tmp): Deleted.
(JSC::B3::Air::LowerToAir::tmpPromise): Deleted.
(JSC::B3::Air::LowerToAir::canBeInternal): Deleted.
(JSC::B3::Air::LowerToAir::commitInternal): Deleted.
(JSC::B3::Air::LowerToAir::crossesInterference): Deleted.
(JSC::B3::Air::LowerToAir::scaleForShl): Deleted.
(JSC::B3::Air::LowerToAir::effectiveAddr): Deleted.
(JSC::B3::Air::LowerToAir::addr): Deleted.
(JSC::B3::Air::LowerToAir::trappingInst): Deleted.
(JSC::B3::Air::LowerToAir::loadPromiseAnyOpcode): Deleted.
(JSC::B3::Air::LowerToAir::loadPromise): Deleted.
(JSC::B3::Air::LowerToAir::imm): Deleted.
(JSC::B3::Air::LowerToAir::bitImm): Deleted.
(JSC::B3::Air::LowerToAir::bitImm64): Deleted.
(JSC::B3::Air::LowerToAir::immOrTmp): Deleted.
(JSC::B3::Air::LowerToAir::tryOpcodeForType): Deleted.
(JSC::B3::Air::LowerToAir::opcodeForType): Deleted.
(JSC::B3::Air::LowerToAir::appendUnOp): Deleted.
(JSC::B3::Air::LowerToAir::preferRightForResult): Deleted.
(JSC::B3::Air::LowerToAir::appendBinOp): Deleted.
(JSC::B3::Air::LowerToAir::appendShift): Deleted.
(JSC::B3::Air::LowerToAir::tryAppendStoreUnOp): Deleted.
(JSC::B3::Air::LowerToAir::tryAppendStoreBinOp): Deleted.
(JSC::B3::Air::LowerToAir::createStore): Deleted.
(JSC::B3::Air::LowerToAir::storeOpcode): Deleted.
(JSC::B3::Air::LowerToAir::appendStore): Deleted.
(JSC::B3::Air::LowerToAir::moveForType): Deleted.
(JSC::B3::Air::LowerToAir::relaxedMoveForType): Deleted.
(JSC::B3::Air::LowerToAir::print): Deleted.
(JSC::B3::Air::LowerToAir::append): Deleted.
(JSC::B3::Air::LowerToAir::appendTrapping): Deleted.
(JSC::B3::Air::LowerToAir::finishAppendingInstructions): Deleted.
(JSC::B3::Air::LowerToAir::newBlock): Deleted.
(JSC::B3::Air::LowerToAir::splitBlock): Deleted.
(JSC::B3::Air::LowerToAir::ensureSpecial): Deleted.
(JSC::B3::Air::LowerToAir::ensureCheckSpecial): Deleted.
(JSC::B3::Air::LowerToAir::fillStackmap): Deleted.
(JSC::B3::Air::LowerToAir::createGenericCompare): Deleted.
(JSC::B3::Air::LowerToAir::createBranch): Deleted.
(JSC::B3::Air::LowerToAir::createCompare): Deleted.
(JSC::B3::Air::LowerToAir::createSelect): Deleted.
(JSC::B3::Air::LowerToAir::tryAppendLea): Deleted.
(JSC::B3::Air::LowerToAir::appendX86Div): Deleted.
(JSC::B3::Air::LowerToAir::appendX86UDiv): Deleted.
(JSC::B3::Air::LowerToAir::loadLinkOpcode): Deleted.
(JSC::B3::Air::LowerToAir::storeCondOpcode): Deleted.
(JSC::B3::Air::LowerToAir::appendCAS): Deleted.
(JSC::B3::Air::LowerToAir::appendVoidAtomic): Deleted.
(JSC::B3::Air::LowerToAir::appendGeneralAtomic): Deleted.
(JSC::B3::Air::LowerToAir::lower): Deleted.

  • b3/B3PatchpointSpecial.cpp:

(JSC::B3::PatchpointSpecial::generate):

  • b3/B3ReduceDoubleToFloat.cpp:

(JSC::B3::reduceDoubleToFloat):

  • b3/B3ReduceStrength.cpp:
  • b3/B3StackmapGenerationParams.cpp:
  • b3/B3StackmapSpecial.cpp:

(JSC::B3::StackmapSpecial::repsImpl):
(JSC::B3::StackmapSpecial::repForArg):

  • b3/air/AirAllocateStackByGraphColoring.cpp:

(JSC::B3::Air::allocateStackByGraphColoring):

  • b3/air/AirEmitShuffle.cpp:

(JSC::B3::Air::emitShuffle):

  • b3/air/AirFixObviousSpills.cpp:
  • b3/air/AirLowerAfterRegAlloc.cpp:

(JSC::B3::Air::lowerAfterRegAlloc):

  • b3/air/AirStackAllocation.cpp:

(JSC::B3::Air::attemptAssignment):
(JSC::B3::Air::assign):

  • bytecode/AccessCase.cpp:

(JSC::AccessCase::generateImpl):

  • bytecode/CallLinkStatus.cpp:

(JSC::CallLinkStatus::computeDFGStatuses):

  • bytecode/GetterSetterAccessCase.cpp:

(JSC::GetterSetterAccessCase::emitDOMJITGetter):

  • bytecode/ObjectPropertyConditionSet.cpp:
  • bytecode/PolymorphicAccess.cpp:

(JSC::PolymorphicAccess::addCases):
(JSC::PolymorphicAccess::regenerate):

  • bytecode/PropertyCondition.cpp:

(JSC::PropertyCondition::isStillValidAssumingImpurePropertyWatchpoint const):

  • bytecode/StructureStubInfo.cpp:

(JSC::StructureStubInfo::addAccessCase):

  • dfg/DFGArgumentsEliminationPhase.cpp:
  • dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::DelayedSetLocal::DelayedSetLocal):
(JSC::DFG::ByteCodeParser::inliningCost):
(JSC::DFG::ByteCodeParser::inlineCall):
(JSC::DFG::ByteCodeParser::attemptToInlineCall):
(JSC::DFG::ByteCodeParser::handleInlining):
(JSC::DFG::ByteCodeParser::planLoad):
(JSC::DFG::ByteCodeParser::store):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::linkBlock):
(JSC::DFG::ByteCodeParser::linkBlocks):

  • dfg/DFGCSEPhase.cpp:
  • dfg/DFGInPlaceAbstractState.cpp:

(JSC::DFG::InPlaceAbstractState::merge):

  • dfg/DFGIntegerCheckCombiningPhase.cpp:

(JSC::DFG::IntegerCheckCombiningPhase::handleBlock):

  • dfg/DFGIntegerRangeOptimizationPhase.cpp:
  • dfg/DFGMovHintRemovalPhase.cpp:
  • dfg/DFGObjectAllocationSinkingPhase.cpp:
  • dfg/DFGPhantomInsertionPhase.cpp:
  • dfg/DFGPutStackSinkingPhase.cpp:
  • dfg/DFGStoreBarrierInsertionPhase.cpp:
  • dfg/DFGVarargsForwardingPhase.cpp:
  • ftl/FTLAbstractHeap.cpp:

(JSC::FTL::AbstractHeap::compute):

  • ftl/FTLAbstractHeapRepository.cpp:

(JSC::FTL::AbstractHeapRepository::decorateMemory):
(JSC::FTL::AbstractHeapRepository::decorateCCallRead):
(JSC::FTL::AbstractHeapRepository::decorateCCallWrite):
(JSC::FTL::AbstractHeapRepository::decoratePatchpointRead):
(JSC::FTL::AbstractHeapRepository::decoratePatchpointWrite):
(JSC::FTL::AbstractHeapRepository::decorateFenceRead):
(JSC::FTL::AbstractHeapRepository::decorateFenceWrite):
(JSC::FTL::AbstractHeapRepository::decorateFencedAccess):
(JSC::FTL::AbstractHeapRepository::computeRangesAndDecorateInstructions):

  • ftl/FTLLink.cpp:

(JSC::FTL::link):

  • heap/MarkingConstraintSet.cpp:

(JSC::MarkingConstraintSet::add):

  • interpreter/ShadowChicken.cpp:

(JSC::ShadowChicken::update):

  • jit/BinarySwitch.cpp:

(JSC::BinarySwitch::BinarySwitch):
(JSC::BinarySwitch::build):

  • llint/LLIntData.cpp:

(JSC::LLInt::Data::loadStats):
(JSC::LLInt::Data::saveStats):

  • runtime/ArrayPrototype.cpp:

(JSC::ArrayPrototype::tryInitializeSpeciesWatchpoint):
(JSC::ArrayPrototypeAdaptiveInferredPropertyWatchpoint::handleFire):

  • runtime/ErrorInstance.cpp:

(JSC::FindFirstCallerFrameWithCodeblockFunctor::FindFirstCallerFrameWithCodeblockFunctor): Deleted.
(JSC::FindFirstCallerFrameWithCodeblockFunctor::operator()): Deleted.
(JSC::FindFirstCallerFrameWithCodeblockFunctor::foundCallFrame const): Deleted.
(JSC::FindFirstCallerFrameWithCodeblockFunctor::index const): Deleted.

  • runtime/IntlDateTimeFormat.cpp:

(JSC::IntlDateTimeFormat::initializeDateTimeFormat):

  • runtime/PromiseDeferredTimer.cpp:

(JSC::PromiseDeferredTimer::doWork):
(JSC::PromiseDeferredTimer::addPendingPromise):
(JSC::PromiseDeferredTimer::cancelPendingPromise):

  • runtime/TypeProfiler.cpp:

(JSC::TypeProfiler::insertNewLocation):

  • runtime/TypeProfilerLog.cpp:

(JSC::TypeProfilerLog::processLogEntries):

  • runtime/WeakMapPrototype.cpp:

(JSC::protoFuncWeakMapDelete):
(JSC::protoFuncWeakMapGet):
(JSC::protoFuncWeakMapHas):
(JSC::protoFuncWeakMapSet):
(JSC::getWeakMapData): Deleted.

  • runtime/WeakSetPrototype.cpp:

(JSC::protoFuncWeakSetDelete):
(JSC::protoFuncWeakSetHas):
(JSC::protoFuncWeakSetAdd):
(JSC::getWeakMapData): Deleted.

  • testRegExp.cpp:

(testOneRegExp):
(runFromFiles):

  • wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::parseAndCompile):

  • wasm/WasmBBQPlan.cpp:

(JSC::Wasm::BBQPlan::moveToState):
(JSC::Wasm::BBQPlan::parseAndValidateModule):
(JSC::Wasm::BBQPlan::prepare):
(JSC::Wasm::BBQPlan::compileFunctions):
(JSC::Wasm::BBQPlan::complete):

  • wasm/WasmFaultSignalHandler.cpp:

(JSC::Wasm::trapHandler):

  • wasm/WasmOMGPlan.cpp:

(JSC::Wasm::OMGPlan::OMGPlan):
(JSC::Wasm::OMGPlan::work):

  • wasm/WasmPlan.cpp:

(JSC::Wasm::Plan::fail):

  • wasm/WasmSignature.cpp:

(JSC::Wasm::SignatureInformation::adopt):

  • wasm/WasmWorklist.cpp:

(JSC::Wasm::Worklist::enqueue):

Source/WTF:

This patch adds a script that will automatically bundle source
files, which is currently only used by the CMake build. It's
important that we use the same script to generate the bundles
for the CMake build as the Xcode build. If we didn't do this then
it's likely that there would be build errors that occur in only
one build system. On the same note, we also need to be careful to
not bundle platform specific source files with platform
independent ones. There are a couple of things the script does not
currently handle but are not essential for the CMake build. First,
it does not handle the max bundle size restrictions that the Xcode
build will require. It also does not handle C files.

The unified source generator script works by collecting groups of
up to 8 files from the same directory. We don't bundle files from
across directories since I didn't see a speedup from doing
so. Additionally, splitting at the directory boundary means that
it is less likely that adding a new file will force a "clean"
build. This would happen because the new file will shift every
subsequent file into the next unified source bundle.

Using unified sources appears to be a roughly 3.5x build time
speed up for clean builds on my MBP and appears to have a
negligible effect in incremental builds.

  • generate-unified-source-bundles.rb: Added.
  • wtf/Assertions.h:
Location:
trunk/Source/JavaScriptCore/b3
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/b3/B3CheckSpecial.cpp

    r216734 r221954  
    3737namespace JSC { namespace B3 {
    3838
    39 using namespace Air;
     39using Inst = Air::Inst;
     40using Arg = Air::Arg;
     41using GenerationContext = Air::GenerationContext;
    4042
    4143namespace {
    4244
    43 unsigned numB3Args(B3::Kind kind)
     45unsigned numB3Args(Kind kind)
    4446{
    4547    switch (kind.opcode()) {
    … …  
    109111void CheckSpecial::forEachArg(Inst& inst, const ScopedLambda<Inst::EachArgCallback>& callback)
    110112{
     113    using namespace Air;
    111114    std::optional<Width> optionalDefArgWidth;
    112115    Inst hidden = hiddenBranch(inst);
    … …  
    157160CCallHelpers::Jump CheckSpecial::generate(Inst& inst, CCallHelpers& jit, GenerationContext& context)
    158161{
     162    using namespace Air;
    159163    CCallHelpers::Jump fail = hiddenBranch(inst).generate(jit, context);
    160164    ASSERT(fail.isSet());

  • trunk/Source/JavaScriptCore/b3/B3DuplicateTails.cpp

    r214636 r221954  
    4545namespace {
    4646
    47 const bool verbose = false;
     47namespace B3DuplicateTailsInternal {
     48static const bool verbose = false;
     49}
    4850
    4951class DuplicateTails {
    … …  
    9597        }
    9698        demoteValues(m_proc, valuesToDemote);
    97         if (verbose) {
     99        if (B3DuplicateTailsInternal::verbose) {
    98100            dataLog("Procedure after value demotion:\n");
    99101            dataLog(m_proc);
    … …  
    117119            candidates.remove(block);
    118120
    119             if (verbose)
     121            if (B3DuplicateTailsInternal::verbose)
    120122                dataLog("Duplicating ", *tail, " into ", *block, "\n");
    121123

  • trunk/Source/JavaScriptCore/b3/B3EliminateCommonSubexpressions.cpp

    r215407 r221954  
    5454namespace {
    5555
    56 const bool verbose = false;
     56namespace B3EliminateCommonSubexpressionsInternal {
     57static const bool verbose = false;
     58}
    5759
    5860// FIXME: We could treat Patchpoints with a non-empty set of reads as a "memory value" and somehow
    … …  
    161163    bool run()
    162164    {
    163         if (verbose)
     165        if (B3EliminateCommonSubexpressionsInternal::verbose)
    164166            dataLog("B3 before CSE:\n", m_proc);
    165167       
    … …  
    189191            }
    190192
    191             if (verbose)
     193            if (B3EliminateCommonSubexpressionsInternal::verbose)
    192194                dataLog("Block ", *block, ": ", data, "\n");
    193195        }
    … …  
    197199        for (unsigned i = postOrder.size(); i--;) {
    198200            m_block = postOrder[i];
    199             if (verbose)
     201            if (B3EliminateCommonSubexpressionsInternal::verbose)
    200202                dataLog("Looking at ", *m_block, ":\n");
    201203
    … …  
    223225        }
    224226
    225         if (verbose)
     227        if (B3EliminateCommonSubexpressionsInternal::verbose)
    226228            dataLog("B3 after CSE:\n", m_proc);
    227229
    … …  
    488490        // operation that interferes.
    489491
    490         if (verbose)
     492        if (B3EliminateCommonSubexpressionsInternal::verbose)
    491493            dataLog(*m_value, ": looking forward for stores to ", *ptr, "...\n");
    492494
    … …  
    558560            return false;
    559561
    560         if (verbose)
     562        if (B3EliminateCommonSubexpressionsInternal::verbose)
    561563            dataLog("Eliminating ", *m_value, " due to ", pointerListDump(matches), "\n");
    562564       
    … …  
    567569            RELEASE_ASSERT(m_dominators.dominates(dominatingMatch->owner, m_block));
    568570           
    569             if (verbose)
     571            if (B3EliminateCommonSubexpressionsInternal::verbose)
    570572                dataLog("    Eliminating using ", *dominatingMatch, "\n");
    571573            Vector<Value*> extraValues;
    … …  
    591593        VariableValue* get = m_insertionSet.insert<VariableValue>(
    592594            m_index, Get, m_value->origin(), variable);
    593         if (verbose)
     595        if (B3EliminateCommonSubexpressionsInternal::verbose)
    594596            dataLog("    Inserting get of value: ", *get, "\n");
    595597        m_value->replaceWithIdentity(get);
    … …  
    616618    MemoryMatches findMemoryValue(Value* ptr, HeapRange range, const Filter& filter)
    617619    {
    618         if (verbose)
     620        if (B3EliminateCommonSubexpressionsInternal::verbose)
    619621            dataLog(*m_value, ": looking backward for ", *ptr, "...\n");
    620622       
    621623        if (m_value->as<MemoryValue>()->hasFence()) {
    622             if (verbose)
     624            if (B3EliminateCommonSubexpressionsInternal::verbose)
    623625                dataLog("    Giving up because fences.\n");
    624626            return { };
    … …  
    626628       
    627629        if (MemoryValue* match = m_data.memoryValuesAtTail.find(ptr, filter)) {
    628             if (verbose)
     630            if (B3EliminateCommonSubexpressionsInternal::verbose)
    629631                dataLog("    Found ", *match, " locally.\n");
    630632            return { match };
    … …  
    632634
    633635        if (m_data.writes.overlaps(range)) {
    634             if (verbose)
     636            if (B3EliminateCommonSubexpressionsInternal::verbose)
    635637                dataLog("    Giving up because of writes.\n");
    636638            return { };
    … …  
    643645
    644646        while (BasicBlock* block = worklist.pop()) {
    645             if (verbose)
     647            if (B3EliminateCommonSubexpressionsInternal::verbose)
    646648                dataLog("    Looking at ", *block, "\n");
    647649
    … …  
    650652            MemoryValue* match = data.memoryValuesAtTail.find(ptr, filter);
    651653            if (match && match != m_value) {
    652                 if (verbose)
     654                if (B3EliminateCommonSubexpressionsInternal::verbose)
    653655                    dataLog("    Found match: ", *match, "\n");
    654656                matches.append(match);
    … …  
    657659
    658660            if (data.writes.overlaps(range)) {
    659                 if (verbose)
     661                if (B3EliminateCommonSubexpressionsInternal::verbose)
    660662                    dataLog("    Giving up because of writes.\n");
    661663                return { };
    … …  
    663665
    664666            if (!block->numPredecessors()) {
    665                 if (verbose)
     667                if (B3EliminateCommonSubexpressionsInternal::verbose)
    666668                    dataLog("    Giving up because it's live at root.\n");
    667669                // This essentially proves that this is live at the prologue. That means that we
    … …  
    673675        }
    674676
    675         if (verbose)
     677        if (B3EliminateCommonSubexpressionsInternal::verbose)
    676678            dataLog("    Got matches: ", pointerListDump(matches), "\n");
    677679        return matches;

  • trunk/Source/JavaScriptCore/b3/B3FixSSA.cpp

    r214917 r221954  
    4949namespace {
    5050
    51 const bool verbose = false;
     51namespace B3FixSSAInternal {
     52static const bool verbose = false;
     53}
    5254
    5355void killDeadVariables(Procedure& proc)
    … …  
    158160               
    159161                Value* phi = proc.add<Value>(Phi, variable->type(), block->at(0)->origin());
    160                 if (verbose) {
     162                if (B3FixSSAInternal::verbose) {
    161163                    dataLog(
    162164                        "Adding Phi for ", pointerDump(variable), " at ", *block, ": ",
    … …  
    232234
    233235                Value* mappedValue = ensureMapping(variable, upsilonInsertionPoint, upsilonOrigin);
    234                 if (verbose) {
     236                if (B3FixSSAInternal::verbose) {
    235237                    dataLog(
    236238                        "Mapped value for ", *variable, " with successor Phi ", *phi,
    … …  
    246248    }
    247249
    248     if (verbose) {
     250    if (B3FixSSAInternal::verbose) {
    249251        dataLog("B3 after SSA conversion:\n");
    250252        dataLog(proc);
    … …  
    267269    }
    268270
    269     if (verbose) {
     271    if (B3FixSSAInternal::verbose) {
    270272        dataLog("Demoting values as follows:\n");
    271273        dataLog("   map = ");

  • trunk/Source/JavaScriptCore/b3/B3FoldPathConstants.cpp

    r219648 r221954  
    4242namespace {
    4343
    44 const bool verbose = false;
     44namespace B3FoldPathConstantsInternal {
     45static const bool verbose = false;
     46}
    4547
    4648class FoldPathConstants {
    … …  
    5658        bool changed = false;
    5759
    58         if (verbose)
     60        if (B3FoldPathConstantsInternal::verbose)
    5961            dataLog("B3 before folding path constants: \n", m_proc, "\n");
    6062       
    … …  
    8183            }
    8284
    83             if (verbose)
     85            if (B3FoldPathConstantsInternal::verbose)
    8486                dataLog("Overriding ", *value, " from ", *from, ": ", override, "\n");
    8587           
    … …  
    150152            }
    151153
    152             if (verbose)
     154            if (B3FoldPathConstantsInternal::verbose)
    153155                dataLog("In block ", *block, " getting override for ", *value, ": ", result, "\n");
    154156

  • trunk/Source/JavaScriptCore/b3/B3InferSwitches.cpp

    r219702 r221954  
    4343namespace {
    4444
    45 const bool verbose = false;
     45namespace B3InferSwitchesInternal {
     46static const bool verbose = false;
     47}
    4648
    4749class InferSwitches {
    … …  
    5658    bool run()
    5759    {
    58         if (verbose)
     60        if (B3InferSwitchesInternal::verbose)
    5961            dataLog("B3 before inferSwitches:\n", m_proc);
    6062       
    … …  
    6466            changed = false;
    6567           
    66             if (verbose)
     68            if (B3InferSwitchesInternal::verbose)
    6769                dataLog("Performing fixpoint iteration:\n");
    6870           
    … …  
    7981            m_proc.deleteOrphans();
    8082           
    81             if (verbose)
     83            if (B3InferSwitchesInternal::verbose)
    8284                dataLog("B3 after inferSwitches:\n", m_proc);
    8385            return true;
    … …  
    9799       
    98100        SwitchDescription description = describe(block);
    99         if (verbose)
     101        if (B3InferSwitchesInternal::verbose)
    100102            dataLog("Description of primary block ", *block, ": ", description, "\n");
    101103        if (!description) {
    102             if (verbose)
     104            if (B3InferSwitchesInternal::verbose)
    103105                dataLog("    Bailing because not switch-like.\n");
    104106            return false;
    … …  
    116118            if (value == description.branch)
    117119                continue;
    118             if (verbose)
     120            if (B3InferSwitchesInternal::verbose)
    119121                dataLog("    Bailing because of ", deepDump(m_proc, value), "\n");
    120122            return false;
    … …  
    123125        BasicBlock* predecessor = block->predecessor(0);
    124126        SwitchDescription predecessorDescription = describe(predecessor);
    125         if (verbose)
     127        if (B3InferSwitchesInternal::verbose)
    126128            dataLog("    Description of predecessor block ", *predecessor, ": ", predecessorDescription, "\n");
    127129        if (!predecessorDescription) {
    128             if (verbose)
     130            if (B3InferSwitchesInternal::verbose)
    129131                dataLog("    Bailing because not switch-like.\n");
    130132            return false;
    … …  
    134136        // We may be switching on different values!
    135137        if (description.source != predecessorDescription.source) {
    136             if (verbose)
     138            if (B3InferSwitchesInternal::verbose)
    137139                dataLog("    Bailing because sources don't match.\n");
    138140            return false;
    … …  
    144146        // yet.
    145147        if (predecessorDescription.fallThrough.block() != block) {
    146             if (verbose)
     148            if (B3InferSwitchesInternal::verbose)
    147149                dataLog("    Bailing because fall-through of predecessor is not the primary block.\n");
    148150            return false;
    … …  
    152154        if (description.fallThrough.block() == block
    153155            || description.fallThrough.block() == predecessor) {
    154             if (verbose)
     156            if (B3InferSwitchesInternal::verbose)
    155157                dataLog("    Bailing because of fall-through loop.\n");
    156158            return false;
    … …  
    159161            if (switchCase.targetBlock() == block
    160162                || switchCase.targetBlock() == predecessor) {
    161                 if (verbose)
     163                if (B3InferSwitchesInternal::verbose)
    162164                    dataLog("    Bailing because of loop in primary cases.\n");
    163165                return false;
    … …  
    167169            if (switchCase.targetBlock() == block
    168170                || switchCase.targetBlock() == predecessor) {
    169                 if (verbose)
     171                if (B3InferSwitchesInternal::verbose)
    170172                    dataLog("    Bailing because of loop in predecessor cases.\n");
    171173                return false;
    … …  
    173175        }
    174176       
    175         if (verbose)
     177        if (B3InferSwitchesInternal::verbose)
    176178            dataLog("    Doing it!\n");
    177179        // We're committed to doing the thing.

  • trunk/Source/JavaScriptCore/b3/B3LowerMacrosAfterOptimizations.cpp

    r213714 r221954  
    2929#if ENABLE(B3_JIT)
    3030
     31#include "AirArg.h"
    3132#include "B3BasicBlockInlines.h"
    3233#include "B3BlockInsertionSet.h"
    … …  
    4041namespace JSC { namespace B3 {
    4142
     43using Arg = Air::Arg;
     44using Code = Air::Code;
     45using Tmp = Air::Tmp;
     46
    4247namespace {
    4348
    44 class LowerMacros {
     49class LowerMacrosAfterOptimizations {
    4550public:
    46     LowerMacros(Procedure& proc)
     51    LowerMacrosAfterOptimizations(Procedure& proc)
    4752        : m_proc(proc)
    4853        , m_blockInsertionSet(proc)
    … …  
    184189bool lowerMacrosImpl(Procedure& proc)
    185190{
    186     LowerMacros lowerMacros(proc);
     191    LowerMacrosAfterOptimizations lowerMacros(proc);
    187192    return lowerMacros.run();
    188193}

  • trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp

    r220823 r221954  
    7070namespace JSC { namespace B3 {
    7171
    72 using namespace Air;
    73 
    7472namespace {
    7573
    76 const bool verbose = false;
     74namespace B3LowerToAirInternal {
     75static const bool verbose = false;
     76}
     77
     78using Arg = Air::Arg;
     79using Inst = Air::Inst;
     80using Code = Air::Code;
     81using Tmp = Air::Tmp;
    7782
    7883// FIXME: We wouldn't need this if Air supported Width modifiers in Air::Kind.
    7984// https://bugs.webkit.org/show_bug.cgi?id=169247
    8085#define OPCODE_FOR_WIDTH(opcode, width) ( \
    81     (width) == Width8 ? opcode ## 8 : \
    82     (width) == Width16 ? opcode ## 16 : \
    83     (width) == Width32 ? opcode ## 32 : \
    84     opcode ## 64)
     86    (width) == Width8 ? Air::opcode ## 8 : \
     87    (width) == Width16 ? Air::opcode ## 16 :    \
     88    (width) == Width32 ? Air::opcode ## 32 :    \
     89    Air::opcode ## 64)
    8590#define OPCODE_FOR_CANONICAL_WIDTH(opcode, width) ( \
    86     (width) == Width64 ? opcode ## 64 : opcode ## 32)
     91    (width) == Width64 ? Air::opcode ## 64 : Air::opcode ## 32)
    8792
    8893class LowerToAir {
    … …  
    108113    void run()
    109114    {
     115        using namespace Air;
    110116        for (B3::BasicBlock* block : m_procedure)
    111117            m_blockToBlock[block] = m_code.addBlock(block->frequency());
    … …  
    115121            case Phi: {
    116122                m_phiToTmp[value] = m_code.newTmp(value->resultBank());
    117                 if (verbose)
     123                if (B3LowerToAirInternal::verbose)
    118124                    dataLog("Phi tmp for ", *value, ": ", m_phiToTmp[value], "\n");
    119125                break;
    … …  
    147153            m_isRare = !m_fastWorklist.saw(block);
    148154
    149             if (verbose)
     155            if (B3LowerToAirInternal::verbose)
    150156                dataLog("Lowering Block ", *block, ":\n");
    151157           
    … …  
    164170                    continue;
    165171                m_insts.append(Vector<Inst>());
    166                 if (verbose)
     172                if (B3LowerToAirInternal::verbose)
    167173                    dataLog("Lowering ", deepDump(m_procedure, m_value), ":\n");
    168174                lower();
    169                 if (verbose) {
     175                if (B3LowerToAirInternal::verbose) {
    170176                    for (Inst& inst : m_insts.last())
    171177                        dataLog("    ", inst, "\n");
    … …  
    380386                if (m_procedure.isFastConstant(value->key()))
    381387                    m_code.addFastTmp(realTmp);
    382                 if (verbose)
     388                if (B3LowerToAirInternal::verbose)
    383389                    dataLog("Tmp for ", *value, ": ", realTmp, "\n");
    384390            }
    … …  
    907913    void appendShift(Value* value, Value* amount)
    908914    {
     915        using namespace Air;
    909916        Air::Opcode opcode = opcodeForType(opcode32, opcode64, value->type());
    910917       
    … …  
    10201027    Inst createStore(Air::Kind move, Value* value, const Arg& dest)
    10211028    {
     1029        using namespace Air;
    10221030        if (auto imm_value = imm(value)) {
    10231031            if (isARM64() && imm_value.value() == 0) {
    … …  
    10441052    Air::Opcode storeOpcode(Width width, Bank bank)
    10451053    {
     1054        using namespace Air;
    10461055        switch (width) {
    10471056        case Width8:
    … …  
    10741083    void appendStore(Value* value, const Arg& dest)
    10751084    {
     1085        using namespace Air;
    10761086        MemoryValue* memory = value->as<MemoryValue>();
    10771087        RELEASE_ASSERT(memory->isStore());
    … …  
    11011111    Air::Opcode moveForType(Type type)
    11021112    {
     1113        using namespace Air;
    11031114        switch (type) {
    11041115        case Int32:
    … …  
    11201131    Air::Opcode relaxedMoveForType(Type type)
    11211132    {
     1133        using namespace Air;
    11221134        switch (type) {
    11231135        case Int32:
    … …  
    11631175    {
    11641176        auto printList = Printer::makePrintRecordList(arguments...);
    1165         auto printSpecial = static_cast<PrintSpecial*>(m_code.addSpecial(std::make_unique<PrintSpecial>(printList)));
    1166         Inst inst(Patch, origin, Arg::special(printSpecial));
     1177        auto printSpecial = static_cast<Air::PrintSpecial*>(m_code.addSpecial(std::make_unique<Air::PrintSpecial>(printList)));
     1178        Inst inst(Air::Patch, origin, Arg::special(printSpecial));
    11671179        Printer::appendAirArgs(inst, std::forward<Arguments>(arguments)...);
    11681180        append(WTFMove(inst));
    … …  
    17631775    Inst createBranch(Value* value, bool inverted = false)
    17641776    {
     1777        using namespace Air;
    17651778        return createGenericCompare(
    17661779            value,
    … …  
    18461859    Inst createCompare(Value* value, bool inverted = false)
    18471860    {
     1861        using namespace Air;
    18481862        return createGenericCompare(
    18491863            value,
    … …  
    19251939    Inst createSelect(const MoveConditionallyConfig& config)
    19261940    {
     1941        using namespace Air;
    19271942        auto createSelectInstruction = [&] (Air::Opcode opcode, const Arg& condition, ArgPromise& left, ArgPromise& right) -> Inst {
    19281943            if (isValidForm(opcode, condition.kind(), left.kind(), right.kind(), Arg::Tmp, Arg::Tmp, Arg::Tmp)) {
    … …  
    19882003    bool tryAppendLea()
    19892004    {
     2005        using namespace Air;
    19902006        Air::Opcode leaOpcode = tryOpcodeForType(Lea32, Lea64, m_value->type());
    19912007        if (!isValidForm(leaOpcode, Arg::Index, Arg::Tmp))
    … …  
    21172133    void appendX86Div(B3::Opcode op)
    21182134    {
     2135        using namespace Air;
    21192136        Air::Opcode convertToDoubleWord;
    21202137        Air::Opcode div;
    … …  
    21442161    void appendX86UDiv(B3::Opcode op)
    21452162    {
     2163        using namespace Air;
    21462164        Air::Opcode div = m_value->type() == Int32 ? X86UDiv32 : X86UDiv64;
    21472165
    … …  
    21792197    void appendCAS(Value* atomicValue, bool invert)
    21802198    {
     2199        using namespace Air;
    21812200        AtomicValue* atomic = atomicValue->as<AtomicValue>();
    21822201        RELEASE_ASSERT(atomic);
    … …  
    23412360    void appendGeneralAtomic(Air::Opcode opcode, Commutativity commutativity = NotCommutative)
    23422361    {
     2362        using namespace Air;
    23432363        AtomicValue* atomic = m_value->as<AtomicValue>();
    23442364       
    … …  
    24252445    void lower()
    24262446    {
     2447        using namespace Air;
    24272448        switch (m_value->opcode()) {
    24282449        case B3::Nop: {

  • trunk/Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp

    r216306 r221954  
    3535namespace JSC { namespace B3 {
    3636
    37 using namespace Air;
     37using Arg = Air::Arg;
     38using Inst = Air::Inst;
    3839
    3940PatchpointSpecial::PatchpointSpecial()
    … …  
    136137}
    137138
    138 CCallHelpers::Jump PatchpointSpecial::generate(
    139     Inst& inst, CCallHelpers& jit, GenerationContext& context)
     139CCallHelpers::Jump PatchpointSpecial::generate(Inst& inst, CCallHelpers& jit, Air::GenerationContext& context)
    140140{
    141141    PatchpointValue* value = inst.origin->as<PatchpointValue>();

  • trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp

    r219026 r221954  
    4040namespace {
    4141
    42 bool verbose = false;
     42namespace B3ReduceDoubleToFloatInternal {
     43static const bool verbose = false;
     44}
    4345bool printRemainingConversions = false;
    4446
    … …  
    129131        } while (changedPhiState);
    130132
    131         if (verbose) {
     133        if (B3ReduceDoubleToFloatInternal::verbose) {
    132134            dataLog("Conversion candidates:\n");
    133135            for (BasicBlock* block : m_procedure) {
    … …  
    193195        } while (changedPhiState);
    194196
    195         if (verbose) {
     197        if (B3ReduceDoubleToFloatInternal::verbose) {
    196198            dataLog("Phis containing float values:\n");
    197199            for (BasicBlock* block : m_procedure) {
    … …  
    490492    PhaseScope phaseScope(procedure, "reduceDoubleToFloat");
    491493
    492     if (verbose)
     494    if (B3ReduceDoubleToFloatInternal::verbose)
    493495        dataLog("Before DoubleToFloatReduction:\n", procedure, "\n");
    494496
    … …  
    496498    doubleToFloatReduction.run();
    497499
    498     if (verbose)
     500    if (B3ReduceDoubleToFloatInternal::verbose)
    499501        dataLog("After DoubleToFloatReduction:\n", procedure, "\n");
    500502

  • trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp

    r220625 r221954  
    8989// canonical if x->index() <= y->index().
    9090
    91 bool verbose = false;
     91namespace B3ReduceStrengthInternal {
     92static const bool verbose = false;
     93}
    9294
    9395// FIXME: This IntRange stuff should be refactored into a general constant propagator. It's weird
    … …  
    415417            if (first)
    416418                first = false;
    417             else if (verbose) {
     419            else if (B3ReduceStrengthInternal::verbose) {
    418420                dataLog("B3 after iteration #", index - 1, " of reduceStrength:\n");
    419421                dataLog(m_proc);
    … …  
    453455               
    454456                for (m_index = 0; m_index < block->size(); ++m_index) {
    455                     if (verbose) {
     457                    if (B3ReduceStrengthInternal::verbose) {
    456458                        dataLog(
    457459                            "Looking at ", *block, " #", m_index, ": ",
    … …  
    20362038    void specializeSelect(Value* source)
    20372039    {
    2038         if (verbose)
     2040        if (B3ReduceStrengthInternal::verbose)
    20392041            dataLog("Specializing select: ", deepDump(m_proc, source), "\n");
    20402042
    … …  
    22772279    void simplifyCFG()
    22782280    {
    2279         if (verbose) {
     2281        if (B3ReduceStrengthInternal::verbose) {
    22802282            dataLog("Before simplifyCFG:\n");
    22812283            dataLog(m_proc);
    … …  
    23022304
    23032305        for (BasicBlock* block : m_proc) {
    2304             if (verbose)
     2306            if (B3ReduceStrengthInternal::verbose)
    23052307                dataLog("Considering block ", *block, ":\n");
    23062308
    … …  
    23182320                    BasicBlock* newSuccessor = successor->successorBlock(0);
    23192321                    if (newSuccessor != successor) {
    2320                         if (verbose) {
     2322                        if (B3ReduceStrengthInternal::verbose) {
    23212323                            dataLog(
    23222324                                "Replacing ", pointerDump(block), "->", pointerDump(successor),
    … …  
    23492351                    }
    23502352                    if (allSame) {
    2351                         if (verbose) {
     2353                        if (B3ReduceStrengthInternal::verbose) {
    23522354                            dataLog(
    23532355                                "Changing ", pointerDump(block), "'s terminal to a Jump.\n");
    … …  
    23882390                        newSuccessor->replacePredecessor(successor, block);
    23892391
    2390                     if (verbose) {
     2392                    if (B3ReduceStrengthInternal::verbose) {
    23912393                        dataLog(
    23922394                            "Merged ", pointerDump(block), "->", pointerDump(successor), "\n");
    … …  
    23982400        }
    23992401
    2400         if (m_changedCFG && verbose) {
     2402        if (m_changedCFG && B3ReduceStrengthInternal::verbose) {
    24012403            dataLog("B3 after simplifyCFG:\n");
    24022404            dataLog(m_proc);

  • trunk/Source/JavaScriptCore/b3/B3StackmapGenerationParams.cpp

    r215292 r221954  
    3434
    3535namespace JSC { namespace B3 {
    36 
    37 using namespace Air;
    3836
    3937const RegisterSet& StackmapGenerationParams::usedRegisters() const

  • trunk/Source/JavaScriptCore/b3/B3StackmapSpecial.cpp

    r216306 r221954  
    3535namespace JSC { namespace B3 {
    3636
    37 using namespace Air;
     37using Arg = Air::Arg;
     38using Inst = Air::Inst;
     39using Tmp = Air::Tmp;
    3840
    3941StackmapSpecial::StackmapSpecial()
    … …  
    211213}
    212214
    213 Vector<ValueRep> StackmapSpecial::repsImpl(
    214     GenerationContext& context, unsigned numIgnoredB3Args, unsigned numIgnoredAirArgs, Inst& inst)
     215Vector<ValueRep> StackmapSpecial::repsImpl(Air::GenerationContext& context, unsigned numIgnoredB3Args, unsigned numIgnoredAirArgs, Inst& inst)
    215216{
    216217    Vector<ValueRep> result;
    … …  
    268269}
    269270
    270 ValueRep StackmapSpecial::repForArg(Code& code, const Arg& arg)
     271ValueRep StackmapSpecial::repForArg(Air::Code& code, const Arg& arg)
    271272{
    272273    switch (arg.kind()) {

  • trunk/Source/JavaScriptCore/b3/air/AirAllocateStackByGraphColoring.cpp

    r215310 r221954  
    4343namespace {
    4444
    45 const bool verbose = false;
     45namespace AirAllocateStackByGraphColoringInternal {
     46static const bool verbose = false;
     47}
    4648
    4749struct CoalescableMove {
    … …  
    154156
    155157        auto interfere = [&] (unsigned instIndex) {
    156             if (verbose)
     158            if (AirAllocateStackByGraphColoringInternal::verbose)
    157159                dataLog("Interfering: ", WTF::pointerListDump(localCalc.live()), "\n");
    158160
    … …  
    186188
    187189        for (unsigned instIndex = block->size(); instIndex--;) {
    188             if (verbose)
     190            if (AirAllocateStackByGraphColoringInternal::verbose)
    189191                dataLog("Analyzing: ", block->at(instIndex), "\n");
    190192
    … …  
    233235    }
    234236
    235     if (verbose) {
     237    if (AirAllocateStackByGraphColoringInternal::verbose) {
    236238        for (StackSlot* slot : code.stackSlots())
    237239            dataLog("Interference of ", pointerDump(slot), ": ", pointerListDump(interference[slot]), "\n");

  • trunk/Source/JavaScriptCore/b3/air/AirEmitShuffle.cpp

    r219702 r221954  
    3838namespace {
    3939
    40 bool verbose = false;
     40namespace AirEmitShuffleInternal {
     41static const bool verbose = false;
     42}
    4143
    4244template<typename Functor>
    … …  
    126128    Value* origin)
    127129{
    128     if (verbose) {
     130    if (AirEmitShuffleInternal::verbose) {
    129131        dataLog(
    130132            "Dealing with pairs: ", listDump(pairs), " and scratches ", scratches[0], ", ",
    … …  
    186188            Arg originalSrc = mapping.begin()->key;
    187189            ASSERT(!shifts.contains(originalSrc));
    188             if (verbose)
     190            if (AirEmitShuffleInternal::verbose)
    189191                dataLog("Processing from ", originalSrc, "\n");
    190192           
    … …  
    196198                    // With a shift it's possible that we previously built the tail of this shift.
    197199                    // See if that's the case now.
    198                     if (verbose)
     200                    if (AirEmitShuffleInternal::verbose)
    199201                        dataLog("Trying to append shift at ", src, "\n");
    200202                    currentPairs.appendVector(shifts.take(src));
    … …  
    214216            ASSERT(currentPairs[0].src() == originalSrc);
    215217
    216             if (verbose)
     218            if (AirEmitShuffleInternal::verbose)
    217219                dataLog("currentPairs = ", listDump(currentPairs), "\n");
    218220
    … …  
    226228
    227229            if (isRotate) {
    228                 if (verbose)
     230                if (AirEmitShuffleInternal::verbose)
    229231                    dataLog("It's a rotate.\n");
    230232                Rotate rotate;
    … …  
    278280                currentPairs.shrink(0);
    279281            } else {
    280                 if (verbose)
     282                if (AirEmitShuffleInternal::verbose)
    281283                    dataLog("It's a shift.\n");
    282284                shifts.add(originalSrc, WTFMove(currentPairs));
    … …  
    285287    }
    286288
    287     if (verbose) {
     289    if (AirEmitShuffleInternal::verbose) {
    288290        dataLog("Shifts:\n");
    289291        for (auto& entry : shifts)

  • trunk/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp

    r216027 r221954  
    4040namespace {
    4141
    42 bool verbose = false;
     42namespace AirFixObviousSpillsInternal {
     43static const bool verbose = false;
     44}
    4345
    4446class FixObviousSpills {
    … …  
    5254    void run()
    5355    {
    54         if (verbose)
     56        if (AirFixObviousSpillsInternal::verbose)
    5557            dataLog("Code before fixObviousSpills:\n", m_code);
    5658       
    … …  
    7476                    continue;
    7577
    76                 if (verbose)
     78                if (AirFixObviousSpillsInternal::verbose)
    7779                    dataLog("Executing block ", *m_block, ": ", m_state, "\n");
    7880               
    … …  
    170172        Inst& inst = m_block->at(m_instIndex);
    171173
    172         if (verbose)
     174        if (AirFixObviousSpillsInternal::verbose)
    173175            dataLog("    Executing ", inst, ": ", m_state, "\n");
    174176
    … …  
    176178            &inst, &inst,
    177179            [&] (const Arg& arg, Arg::Role, Bank, Width) {
    178                 if (verbose)
     180                if (AirFixObviousSpillsInternal::verbose)
    179181                    dataLog("        Clobbering ", arg, "\n");
    180182                m_state.clobber(arg);
    … …  
    191193        Inst& inst = m_block->at(m_instIndex);
    192194
    193         if (verbose)
     195        if (AirFixObviousSpillsInternal::verbose)
    194196            dataLog("Fixing inst ", inst, ": ", m_state, "\n");
    195197       
    … …  
    268270                    if (alias->mode != RegSlot::AllBits)
    269271                        return;
    270                     if (verbose)
     272                    if (AirFixObviousSpillsInternal::verbose)
    271273                        dataLog("    Replacing ", arg, " with ", alias->reg, "\n");
    272274                    arg = Tmp(alias->reg);
    … …  
    274276                    return;
    275277                case Width32:
    276                     if (verbose)
     278                    if (AirFixObviousSpillsInternal::verbose)
    277279                        dataLog("    Replacing ", arg, " with ", alias->reg, " (subwidth case)\n");
    278280                    arg = Tmp(alias->reg);
    … …  
    286288            // Revert to immediate if that didn't work.
    287289            if (const SlotConst* alias = m_state.getSlotConst(arg.stackSlot())) {
    288                 if (verbose)
     290                if (AirFixObviousSpillsInternal::verbose)
    289291                    dataLog("    Replacing ", arg, " with constant ", alias->constant, "\n");
    290292                if (Arg::isValidImmForm(alias->constant))

  • trunk/Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp

    r219702 r221954  
    4747namespace {
    4848
    49 bool verbose = false;
     49namespace AirLowerAfterRegAllocInternal {
     50static const bool verbose = false;
     51}
    5052   
    5153} // anonymous namespace
    … …  
    5557    PhaseScope phaseScope(code, "lowerAfterRegAlloc");
    5658
    57     if (verbose)
     59    if (AirLowerAfterRegAllocInternal::verbose)
    5860        dataLog("Code before lowerAfterRegAlloc:\n", code);
    5961   
    … …  
    222224                    });
    223225
    224                 if (verbose)
     226                if (AirLowerAfterRegAllocInternal::verbose)
    225227                    dataLog("Pre-call pairs for ", inst, ": ", listDump(pairs), "\n");
    226228               
    … …  
    274276    }
    275277
    276     if (verbose)
     278    if (AirLowerAfterRegAllocInternal::verbose)
    277279        dataLog("Code after lowerAfterRegAlloc:\n", code);
    278280}

  • trunk/Source/JavaScriptCore/b3/air/AirStackAllocation.cpp

    r215310 r221954  
    3939namespace {
    4040
    41 const bool verbose = false;
     41namespace AirStackAllocationInternal {
     42static const bool verbose = false;
     43}
    4244
    4345template<typename Collection>
    … …  
    5557    StackSlot* slot, intptr_t offsetFromFP, const Vector<StackSlot*>& otherSlots)
    5658{
    57     if (verbose)
     59    if (AirStackAllocationInternal::verbose)
    5860        dataLog("Attempting to assign ", pointerDump(slot), " to ", offsetFromFP, " with interference ", pointerListDump(otherSlots), "\n");
    5961
    … …  
    7375    }
    7476
    75     if (verbose)
     77    if (AirStackAllocationInternal::verbose)
    7678        dataLog("Assigned ", pointerDump(slot), " to ", offsetFromFP, "\n");
    7779    slot->setOffsetFromFP(offsetFromFP);
    … …  
    8183void assign(StackSlot* slot, const Vector<StackSlot*>& otherSlots)
    8284{
    83     if (verbose)
     85    if (AirStackAllocationInternal::verbose)
    8486        dataLog("Attempting to assign ", pointerDump(slot), " with interference ", pointerListDump(otherSlots), "\n");
    8587   
Note: See TracChangeset for help on using the changeset viewer.