Ignore:
Timestamp:
Mar 29, 2017, 3:55:53 PM (8 years ago)
Author:
[email protected]
Message:

LinkBuffer and ExecutableAllocator shouldn't have anything to do with VM
​https://bugs.webkit.org/show_bug.cgi?id=170210

Reviewed by Mark Lam.

Source/JavaScriptCore:

This is one more step in the direction of PIC-ified Wasm.
LinkBuffer and ExecutableAllocator have no business knowing about VM.

  • assembler/LinkBuffer.cpp:

(JSC::LinkBuffer::allocate):

  • assembler/LinkBuffer.h:

(JSC::LinkBuffer::LinkBuffer):
(JSC::LinkBuffer::vm): Deleted.

  • b3/B3Compile.cpp:

(JSC::B3::compile):

  • b3/B3Compile.h:
  • b3/air/testair.cpp:
  • b3/testb3.cpp:

(JSC::B3::compileProc):
(JSC::B3::compileAndRun):
(JSC::B3::testLoadAcq42):
(JSC::B3::testAddArgZeroImmZDef):
(JSC::B3::testAddLoadTwice):
(JSC::B3::testMulLoadTwice):
(JSC::B3::testMulAddArgsLeft):
(JSC::B3::testMulAddArgsRight):
(JSC::B3::testMulAddArgsLeft32):
(JSC::B3::testMulAddArgsRight32):
(JSC::B3::testMulSubArgsLeft):
(JSC::B3::testMulSubArgsRight):
(JSC::B3::testMulSubArgsLeft32):
(JSC::B3::testMulSubArgsRight32):
(JSC::B3::testMulNegArgs):
(JSC::B3::testMulNegArgs32):
(JSC::B3::testCompareFloatToDoubleThroughPhi):
(JSC::B3::testDoubleToFloatThroughPhi):
(JSC::B3::testReduceFloatToDoubleValidates):
(JSC::B3::testDoubleProducerPhiToFloatConversion):
(JSC::B3::testDoubleProducerPhiToFloatConversionWithDoubleConsumer):
(JSC::B3::testDoubleProducerPhiWithNonFloatConst):
(JSC::B3::testIToD64Arg):
(JSC::B3::testIToF64Arg):
(JSC::B3::testIToD32Arg):
(JSC::B3::testIToF32Arg):
(JSC::B3::testIToD64Mem):
(JSC::B3::testIToF64Mem):
(JSC::B3::testIToD32Mem):
(JSC::B3::testIToF32Mem):
(JSC::B3::testIToDReducedToIToF64Arg):
(JSC::B3::testIToDReducedToIToF32Arg):
(JSC::B3::testStoreRelAddLoadAcq32):
(JSC::B3::testStoreRelAddLoadAcq8):
(JSC::B3::testStoreRelAddFenceLoadAcq8):
(JSC::B3::testStoreRelAddLoadAcq16):
(JSC::B3::testStoreRelAddLoadAcq64):
(JSC::B3::testBranch):
(JSC::B3::testBranchPtr):
(JSC::B3::testDiamond):
(JSC::B3::testBranchNotEqual):
(JSC::B3::testBranchNotEqualCommute):
(JSC::B3::testBranchNotEqualNotEqual):
(JSC::B3::testBranchEqual):
(JSC::B3::testBranchEqualEqual):
(JSC::B3::testBranchEqualCommute):
(JSC::B3::testBranchEqualEqual1):
(JSC::B3::testBranchLoadPtr):
(JSC::B3::testBranchLoad32):
(JSC::B3::testBranchLoad8S):
(JSC::B3::testBranchLoad8Z):
(JSC::B3::testBranchLoad16S):
(JSC::B3::testBranchLoad16Z):
(JSC::B3::testBranch8WithLoad8ZIndex):
(JSC::B3::testComplex):
(JSC::B3::testSimpleCheck):
(JSC::B3::testCheckFalse):
(JSC::B3::testCheckTrue):
(JSC::B3::testCheckLessThan):
(JSC::B3::testCheckMegaCombo):
(JSC::B3::testCheckTrickyMegaCombo):
(JSC::B3::testCheckTwoMegaCombos):
(JSC::B3::testCheckTwoNonRedundantMegaCombos):
(JSC::B3::testCheckAddImm):
(JSC::B3::testCheckAddImmCommute):
(JSC::B3::testCheckAddImmSomeRegister):
(JSC::B3::testCheckAdd):
(JSC::B3::testCheckAdd64):
(JSC::B3::testCheckAddFold):
(JSC::B3::testCheckAddFoldFail):
(JSC::B3::testCheckAddSelfOverflow64):
(JSC::B3::testCheckAddSelfOverflow32):
(JSC::B3::testCheckSubImm):
(JSC::B3::testCheckSubBadImm):
(JSC::B3::testCheckSub):
(JSC::B3::testCheckSub64):
(JSC::B3::testCheckSubFold):
(JSC::B3::testCheckSubFoldFail):
(JSC::B3::testCheckNeg):
(JSC::B3::testCheckNeg64):
(JSC::B3::testCheckMul):
(JSC::B3::testCheckMulMemory):
(JSC::B3::testCheckMul2):
(JSC::B3::testCheckMul64):
(JSC::B3::testCheckMulFold):
(JSC::B3::testCheckMulFoldFail):
(JSC::B3::testCheckMul64SShr):
(JSC::B3::testSwitch):
(JSC::B3::testSwitchChillDiv):
(JSC::B3::testSwitchTargettingSameBlock):
(JSC::B3::testSwitchTargettingSameBlockFoldPathConstant):
(JSC::B3::testBasicSelect):
(JSC::B3::testSelectTest):
(JSC::B3::testSelectCompareDouble):
(JSC::B3::testSelectDouble):
(JSC::B3::testSelectDoubleTest):
(JSC::B3::testSelectDoubleCompareDouble):
(JSC::B3::testSelectFloatCompareFloat):
(JSC::B3::testSelectFold):
(JSC::B3::testSelectInvert):
(JSC::B3::testCheckSelect):
(JSC::B3::testCheckSelectCheckSelect):
(JSC::B3::testCheckSelectAndCSE):
(JSC::B3::testTrivialInfiniteLoop):
(JSC::B3::testFoldPathEqual):
(JSC::B3::testLShiftSelf32):
(JSC::B3::testRShiftSelf32):
(JSC::B3::testURShiftSelf32):
(JSC::B3::testLShiftSelf64):
(JSC::B3::testRShiftSelf64):
(JSC::B3::testURShiftSelf64):
(JSC::B3::testPatchpointDoubleRegs):
(JSC::B3::testSpillDefSmallerThanUse):
(JSC::B3::testSpillUseLargerThanDef):
(JSC::B3::testLateRegister):
(JSC::B3::testInterpreter):
(JSC::B3::testEntrySwitchSimple):
(JSC::B3::testEntrySwitchNoEntrySwitch):
(JSC::B3::testEntrySwitchWithCommonPaths):
(JSC::B3::testEntrySwitchWithCommonPathsAndNonTrivialEntrypoint):
(JSC::B3::testEntrySwitchLoop):
(JSC::B3::testSomeEarlyRegister):
(JSC::B3::testTerminalPatchpointThatNeedsToBeSpilled):
(JSC::B3::testTerminalPatchpointThatNeedsToBeSpilled2):
(JSC::B3::testPatchpointTerminalReturnValue):
(JSC::B3::testMemoryFence):
(JSC::B3::testStoreFence):
(JSC::B3::testLoadFence):
(JSC::B3::testPCOriginMapDoesntInsertNops):
(JSC::B3::testPinRegisters):
(JSC::B3::testX86LeaAddAddShlLeft):
(JSC::B3::testX86LeaAddAddShlRight):
(JSC::B3::testX86LeaAddAdd):
(JSC::B3::testX86LeaAddShlRight):
(JSC::B3::testX86LeaAddShlLeftScale1):
(JSC::B3::testX86LeaAddShlLeftScale2):
(JSC::B3::testX86LeaAddShlLeftScale4):
(JSC::B3::testX86LeaAddShlLeftScale8):
(JSC::B3::testAddShl32):
(JSC::B3::testAddShl64):
(JSC::B3::testAddShl65):
(JSC::B3::testLoadBaseIndexShift2):
(JSC::B3::testLoadBaseIndexShift32):
(JSC::B3::testOptimizeMaterialization):
(JSC::B3::testAtomicWeakCAS):
(JSC::B3::testAtomicStrongCAS):
(JSC::B3::testAtomicXchg):
(JSC::B3::testDepend32):
(JSC::B3::testDepend64):
(JSC::B3::testWasmBoundsCheck):
(JSC::B3::testWasmAddress):
(JSC::B3::run):
(JSC::B3::compile): Deleted.

  • bytecode/PolymorphicAccess.cpp:

(JSC::PolymorphicAccess::regenerate):

  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compile):
(JSC::DFG::JITCompiler::compileFunction):

  • dfg/DFGLazyJSValue.cpp:

(JSC::DFG::LazyJSValue::emit):

  • dfg/DFGOSRExitCompiler.cpp:
  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):

  • dfg/DFGThunks.cpp:

(JSC::DFG::osrExitGenerationThunkGenerator):
(JSC::DFG::osrEntryThunkGenerator):

  • ftl/FTLCompile.cpp:

(JSC::FTL::compile):

  • ftl/FTLLazySlowPath.cpp:

(JSC::FTL::LazySlowPath::generate):

  • ftl/FTLLink.cpp:

(JSC::FTL::link):

  • ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstruct):
(JSC::FTL::DFG::LowerDFGToB3::compileTailCall):
(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargsSpread):
(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargs):
(JSC::FTL::DFG::LowerDFGToB3::compileCallEval):

  • ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileStub):

  • ftl/FTLOSRExitHandle.cpp:

(JSC::FTL::OSRExitHandle::emitExitThunk):

  • ftl/FTLSlowPathCall.cpp:

(JSC::FTL::SlowPathCallContext::makeCall):

  • ftl/FTLSlowPathCall.h:

(JSC::FTL::callOperation):

  • ftl/FTLState.h:
  • ftl/FTLThunks.cpp:

(JSC::FTL::genericGenerationThunkGenerator):
(JSC::FTL::slowPathCallThunkGenerator):

  • ftl/FTLThunks.h:

(JSC::FTL::generateIfNecessary):
(JSC::FTL::Thunks::getSlowPathCallThunk):

  • jit/AssemblyHelpers.cpp:

(JSC::AssemblyHelpers::emitDumbVirtualCall):

  • jit/AssemblyHelpers.h:
  • jit/ExecutableAllocator.cpp:

(JSC::ExecutableAllocator::initializeAllocator):
(JSC::ExecutableAllocator::singleton):
(JSC::ExecutableAllocator::ExecutableAllocator):
(JSC::ExecutableAllocator::allocate):

  • jit/ExecutableAllocator.h:
  • jit/JIT.cpp:

(JSC::JIT::compileWithoutLinking):

  • jit/JITCall.cpp:

(JSC::JIT::compileCallEvalSlowCase):

  • jit/JITMathIC.h:

(JSC::JITMathIC::generateOutOfLine):

  • jit/JITOpcodes.cpp:

(JSC::JIT::privateCompileHasIndexedProperty):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileHasIndexedProperty):

  • jit/JITOperations.cpp:
  • jit/JITOperations.h:
  • jit/JITPropertyAccess.cpp:

(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::privateCompileGetByVal):
(JSC::JIT::privateCompileGetByValWithCachedId):
(JSC::JIT::privateCompilePutByVal):
(JSC::JIT::privateCompilePutByValWithCachedId):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::stringGetByValStubGenerator):

  • jit/JITStubRoutine.h:
  • jit/Repatch.cpp:

(JSC::ftlThunkAwareRepatchCall):
(JSC::linkPolymorphicCall):

  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::finalize):

  • jit/ThunkGenerators.cpp:

(JSC::throwExceptionFromCallSlowPathGenerator):
(JSC::linkCallThunkGenerator):
(JSC::linkPolymorphicCallThunkGenerator):
(JSC::virtualThunkFor):
(JSC::nativeForGenerator):
(JSC::arityFixupGenerator):
(JSC::unreachableGenerator):
(JSC::boundThisNoArgsFunctionCallGenerator):
(JSC::throwExceptionFromWasmThunkGenerator):

  • llint/LLIntThunks.cpp:

(JSC::LLInt::generateThunkWithJumpTo):

  • runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::takeSample):

  • runtime/VM.cpp:

(JSC::VM::VM):

  • runtime/VM.h:
  • runtime/VMTraps.cpp:

(JSC::VMTraps::tryInstallTrapBreakpoints):

  • tools/VMInspector.cpp:
  • wasm/WasmBinding.cpp:

(JSC::Wasm::wasmToJs):
(JSC::Wasm::wasmToWasm):
(JSC::Wasm::exitStubGenerator):

  • wasm/WasmPlan.cpp:

(JSC::Wasm::Plan::complete):

  • yarr/YarrJIT.cpp:

(JSC::Yarr::YarrGenerator::compile):
(JSC::Yarr::jitCompile):

Source/WebCore:

  • cssjit/SelectorCompiler.cpp:

(WebCore::SelectorCompiler::compileSelector):
(WebCore::SelectorCompiler::SelectorCodeGenerator::compile):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r214531 r214571  
    6767#include "LinkBuffer.h"
    6868#include "PureNaN.h"
    69 #include "VM.h"
    7069#include <cmath>
    7170#include <string>
    … …  
    119118    } while (false)
    120119
    121 VM* vm;
    122 
    123 std::unique_ptr<Compilation> compile(Procedure& procedure, unsigned optLevel = 1)
    124 {
    125     return std::make_unique<Compilation>(B3::compile(*vm, procedure, optLevel));
     120std::unique_ptr<Compilation> compileProc(Procedure& procedure, unsigned optLevel = 1)
     121{
     122    return std::make_unique<Compilation>(B3::compile(procedure, optLevel));
    126123}
    127124
    … …  
    142139T compileAndRun(Procedure& procedure, Arguments... arguments)
    143140{
    144     return invoke<T>(*compile(procedure), arguments...);
     141    return invoke<T>(*compileProc(procedure), arguments...);
    145142}
    146143
    … …  
    313310            0, HeapRange(42), HeapRange(42)));
    314311
    315     auto code = compile(proc);
     312    auto code = compileProc(proc);
    316313    if (isARM64())
    317314        checkUsesInstruction(*code, "lda");
    … …  
    616613            constZero));
    617614
    618     auto code = compile(proc, 0);
     615    auto code = compileProc(proc, 0);
    619616    CHECK(invoke<int64_t>(*code, 0x0123456789abcdef) == 0x89abcdef);
    620617}
    … …  
    633630            root->appendNew<Value>(proc, Add, Origin(), load, load));
    634631
    635         auto code = compile(proc, optLevel);
     632        auto code = compileProc(proc, optLevel);
    636633        CHECK(invoke<int32_t>(*code) == 42 * 2);
    637634    };
    … …  
    985982            root->appendNew<Value>(proc, Mul, Origin(), load, load));
    986983
    987         auto code = compile(proc, optLevel);
     984        auto code = compileProc(proc, optLevel);
    988985        CHECK(invoke<int32_t>(*code) == 42 * 42);
    989986    };
    … …  
    10051002    root->appendNewControlValue(proc, Return, Origin(), added);
    10061003
    1007     auto code = compile(proc);
     1004    auto code = compileProc(proc);
    10081005
    10091006    auto testValues = int64Operands();
    … …  
    10291026    root->appendNewControlValue(proc, Return, Origin(), added);
    10301027
    1031     auto code = compile(proc);
     1028    auto code = compileProc(proc);
    10321029
    10331030    auto testValues = int64Operands();
    … …  
    10561053    root->appendNewControlValue(proc, Return, Origin(), added);
    10571054
    1058     auto code = compile(proc);
     1055    auto code = compileProc(proc);
    10591056
    10601057    auto testValues = int32Operands();
    … …  
    10831080    root->appendNewControlValue(proc, Return, Origin(), added);
    10841081
    1085     auto code = compile(proc);
     1082    auto code = compileProc(proc);
    10861083
    10871084    auto testValues = int32Operands();
    … …  
    11071104    root->appendNewControlValue(proc, Return, Origin(), added);
    11081105
    1109     auto code = compile(proc);
     1106    auto code = compileProc(proc);
    11101107
    11111108    auto testValues = int64Operands();
    … …  
    11311128    root->appendNewControlValue(proc, Return, Origin(), added);
    11321129
    1133     auto code = compile(proc);
     1130    auto code = compileProc(proc);
    11341131
    11351132    auto testValues = int64Operands();
    … …  
    11581155    root->appendNewControlValue(proc, Return, Origin(), added);
    11591156
    1160     auto code = compile(proc);
     1157    auto code = compileProc(proc);
    11611158
    11621159    auto testValues = int32Operands();
    … …  
    11851182    root->appendNewControlValue(proc, Return, Origin(), added);
    11861183
    1187     auto code = compile(proc);
     1184    auto code = compileProc(proc);
    11881185
    11891186    auto testValues = int32Operands();
    … …  
    12091206    root->appendNewControlValue(proc, Return, Origin(), added);
    12101207
    1211     auto code = compile(proc);
     1208    auto code = compileProc(proc);
    12121209
    12131210    auto testValues = int64Operands();
    … …  
    12331230    root->appendNewControlValue(proc, Return, Origin(), added);
    12341231
    1235     auto code = compile(proc);
     1232    auto code = compileProc(proc);
    12361233
    12371234    auto testValues = int32Operands();
    … …  
    46374634    tail->appendNewControlValue(proc, Return, Origin(), equal);
    46384635
    4639     auto code = compile(proc);
     4636    auto code = compileProc(proc);
    46404637    int32_t integerA = bitwise_cast<int32_t>(a);
    46414638    double doubleB = b;
    … …  
    46864683    tail->appendNewControlValue(proc, Return, Origin(), floatResult);
    46874684
    4688     auto code = compile(proc);
     4685    auto code = compileProc(proc);
    46894686    CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + 42.5f));
    46904687    CHECK(isIdentical(invoke<float>(*code, 0, bitwise_cast<int32_t>(value)), static_cast<float>(M_PI)));
    … …  
    47414738    tail->appendNewControlValue(proc, Return, Origin(), result);
    47424739
    4743     auto code = compile(proc);
     4740    auto code = compileProc(proc);
    47444741    CHECK(isIdentical(invoke<float>(*code, 1), 11.5f * 11.5f + static_cast<float>(bitwise_cast<double>(static_cast<uint64_t>(1))) + 11.5f));
    47454742    CHECK(isIdentical(invoke<float>(*code, 0), 10.5f * 10.5f + static_cast<float>(bitwise_cast<double>(static_cast<uint64_t>(0))) + 10.5f));
    … …  
    47814778    tail->appendNewControlValue(proc, Return, Origin(), floatResult);
    47824779
    4783     auto code = compile(proc);
     4780    auto code = compileProc(proc);
    47844781    CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + value));
    47854782    CHECK(isIdentical(invoke<float>(*code, 0, bitwise_cast<int32_t>(value)), 42.5f + value));
    … …  
    48304827    tail->appendNewControlValue(proc, Return, Origin(), doubleAdd);
    48314828
    4832     auto code = compile(proc);
     4829    auto code = compileProc(proc);
    48334830    CHECK(isIdentical(invoke<double>(*code, 1, bitwise_cast<int32_t>(value)), (value + value) + static_cast<double>(value)));
    48344831    CHECK(isIdentical(invoke<double>(*code, 0, bitwise_cast<int32_t>(value)), static_cast<double>((42.5f + value) + 42.5f)));
    … …  
    48704867    tail->appendNewControlValue(proc, Return, Origin(), floatResult);
    48714868
    4872     auto code = compile(proc);
     4869    auto code = compileProc(proc);
    48734870    CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + value));
    48744871    CHECK(isIdentical(invoke<float>(*code, 0, bitwise_cast<int32_t>(value)), static_cast<float>(constValue + value)));
    … …  
    52265223    root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
    52275224
    5228     auto code = compile(proc);
     5225    auto code = compileProc(proc);
    52295226    for (auto testValue : int64Operands())
    52305227        CHECK(isIdentical(invoke<double>(*code, testValue.value), static_cast<double>(testValue.value)));
    … …  
    52395236    root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
    52405237
    5241     auto code = compile(proc);
     5238    auto code = compileProc(proc);
    52425239    for (auto testValue : int64Operands())
    52435240        CHECK(isIdentical(invoke<float>(*code, testValue.value), static_cast<float>(testValue.value)));
    … …  
    52535250    root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
    52545251
    5255     auto code = compile(proc);
     5252    auto code = compileProc(proc);
    52565253    for (auto testValue : int32Operands())
    52575254        CHECK(isIdentical(invoke<double>(*code, testValue.value), static_cast<double>(testValue.value)));
    … …  
    52675264    root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
    52685265
    5269     auto code = compile(proc);
     5266    auto code = compileProc(proc);
    52705267    for (auto testValue : int32Operands())
    52715268        CHECK(isIdentical(invoke<float>(*code, testValue.value), static_cast<float>(testValue.value)));
    … …  
    52815278    root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
    52825279
    5283     auto code = compile(proc);
     5280    auto code = compileProc(proc);
    52845281    int64_t inMemoryValue;
    52855282    for (auto testValue : int64Operands()) {
    … …  
    52995296    root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
    53005297
    5301     auto code = compile(proc);
     5298    auto code = compileProc(proc);
    53025299    int64_t inMemoryValue;
    53035300    for (auto testValue : int64Operands()) {
    … …  
    53175314    root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
    53185315
    5319     auto code = compile(proc);
     5316    auto code = compileProc(proc);
    53205317    int32_t inMemoryValue;
    53215318    for (auto testValue : int32Operands()) {
    … …  
    53355332    root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
    53365333
    5337     auto code = compile(proc);
     5334    auto code = compileProc(proc);
    53385335    int32_t inMemoryValue;
    53395336    for (auto testValue : int32Operands()) {
    … …  
    53935390    root->appendNewControlValue(proc, Return, Origin(), floatResult);
    53945391
    5395     auto code = compile(proc);
     5392    auto code = compileProc(proc);
    53965393    for (auto testValue : int64Operands())
    53975394        CHECK(isIdentical(invoke<float>(*code, testValue.value), static_cast<float>(testValue.value)));
    … …  
    54085405    root->appendNewControlValue(proc, Return, Origin(), floatResult);
    54095406
    5410     auto code = compile(proc);
     5407    auto code = compileProc(proc);
    54115408    for (auto testValue : int32Operands())
    54125409        CHECK(isIdentical(invoke<float>(*code, testValue.value), static_cast<float>(testValue.value)));
    … …  
    57905787        root->appendNew<Const32Value>(proc, Origin(), 0));
    57915788
    5792     auto code = compile(proc);
     5789    auto code = compileProc(proc);
    57935790    if (isARM64()) {
    57945791        checkUsesInstruction(*code, "lda");
    … …  
    58635860        root->appendNew<Const32Value>(proc, Origin(), 0));
    58645861
    5865     auto code = compile(proc);
     5862    auto code = compileProc(proc);
    58665863    if (isARM64()) {
    58675864        checkUsesInstruction(*code, "lda");
    … …  
    59025899        root->appendNew<Const32Value>(proc, Origin(), 0));
    59035900
    5904     auto code = compile(proc);
     5901    auto code = compileProc(proc);
    59055902    if (isARM64()) {
    59065903        checkUsesInstruction(*code, "lda");
    … …  
    59755972        root->appendNew<Const32Value>(proc, Origin(), 0));
    59765973
    5977     auto code = compile(proc);
     5974    auto code = compileProc(proc);
    59785975    if (isARM64()) {
    59795976        checkUsesInstruction(*code, "lda");
    … …  
    60446041        root->appendNew<Const32Value>(proc, Origin(), 0));
    60456042
    6046     auto code = compile(proc);
     6043    auto code = compileProc(proc);
    60476044    if (isARM64()) {
    60486045        checkUsesInstruction(*code, "lda");
    … …  
    70507047        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    70517048
    7052     auto code = compile(proc);
     7049    auto code = compileProc(proc);
    70537050    CHECK(invoke<int>(*code, 42) == 1);
    70547051    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    70757072        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    70767073
    7077     auto code = compile(proc);
     7074    auto code = compileProc(proc);
    70787075    CHECK(invoke<int>(*code, static_cast<intptr_t>(42)) == 1);
    70797076    CHECK(invoke<int>(*code, static_cast<intptr_t>(0)) == 0);
    … …  
    71087105    done->appendNewControlValue(proc, Return, Origin(), phi);
    71097106
    7110     auto code = compile(proc);
     7107    auto code = compileProc(proc);
    71117108    CHECK(invoke<int>(*code, 42) == 1);
    71127109    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    71387135        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    71397136
    7140     auto code = compile(proc);
     7137    auto code = compileProc(proc);
    71417138    CHECK(invoke<int>(*code, 42) == 1);
    71427139    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    71687165        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    71697166
    7170     auto code = compile(proc);
     7167    auto code = compileProc(proc);
    71717168    CHECK(invoke<int>(*code, 42) == 1);
    71727169    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    72017198        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    72027199
    7203     auto code = compile(proc);
     7200    auto code = compileProc(proc);
    72047201    CHECK(invoke<int>(*code, 42) == 1);
    72057202    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    72317228        elseCase->appendNew<Const32Value>(proc, Origin(), 1));
    72327229
    7233     auto code = compile(proc);
     7230    auto code = compileProc(proc);
    72347231    CHECK(invoke<int>(*code, 42) == 1);
    72357232    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    72647261        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    72657262
    7266     auto code = compile(proc);
     7263    auto code = compileProc(proc);
    72677264    CHECK(invoke<int>(*code, 42) == 1);
    72687265    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    72947291        elseCase->appendNew<Const32Value>(proc, Origin(), 1));
    72957292
    7296     auto code = compile(proc);
     7293    auto code = compileProc(proc);
    72977294    CHECK(invoke<int>(*code, 42) == 1);
    72987295    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    73277324        elseCase->appendNew<Const32Value>(proc, Origin(), 1));
    73287325
    7329     auto code = compile(proc);
     7326    auto code = compileProc(proc);
    73307327    CHECK(invoke<int>(*code, 42) == 1);
    73317328    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    77427739        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    77437740
    7744     auto code = compile(proc);
     7741    auto code = compileProc(proc);
    77457742    intptr_t cond;
    77467743    cond = 42;
    … …  
    77727769        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    77737770
    7774     auto code = compile(proc);
     7771    auto code = compileProc(proc);
    77757772    int32_t cond;
    77767773    cond = 42;
    … …  
    78027799        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    78037800
    7804     auto code = compile(proc);
     7801    auto code = compileProc(proc);
    78057802    int8_t cond;
    78067803    cond = -1;
    … …  
    78327829        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    78337830
    7834     auto code = compile(proc);
     7831    auto code = compileProc(proc);
    78357832    uint8_t cond;
    78367833    cond = 1;
    … …  
    78627859        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    78637860
    7864     auto code = compile(proc);
     7861    auto code = compileProc(proc);
    78657862    int16_t cond;
    78667863    cond = -1;
    … …  
    78927889        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    78937890
    7894     auto code = compile(proc);
     7891    auto code = compileProc(proc);
    78957892    uint16_t cond;
    78967893    cond = 1;
    … …  
    79327929        elseCase->appendNew<Const32Value>(proc, Origin(), 0));
    79337930
    7934     auto code = compile(proc);
     7931    auto code = compileProc(proc);
    79357932    uint32_t cond;
    79367933    cond = 0xffffffffU; // All bytes are 0xff.
    … …  
    80698066    current->appendNewControlValue(proc, Return, Origin(), vars[0]);
    80708067
    8071     compile(proc);
     8068    compileProc(proc);
    80728069
    80738070    double after = monotonicallyIncreasingTimeMS();
    … …  
    86188615        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    86198616
    8620     auto code = compile(proc);
     8617    auto code = compileProc(proc);
    86218618   
    86228619    CHECK(invoke<int>(*code, 0) == 0);
    … …  
    86378634        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    86388635
    8639     auto code = compile(proc);
     8636    auto code = compileProc(proc);
    86408637   
    86418638    CHECK(invoke<int>(*code) == 0);
    … …  
    86638660        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    86648661
    8665     auto code = compile(proc);
     8662    auto code = compileProc(proc);
    86668663   
    86678664    CHECK(invoke<int>(*code) == 42);
    … …  
    86948691        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    86958692
    8696     auto code = compile(proc);
     8693    auto code = compileProc(proc);
    86978694   
    86988695    CHECK(invoke<int>(*code, 42) == 0);
    … …  
    87408737        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    87418738
    8742     auto code = compile(proc);
     8739    auto code = compileProc(proc);
    87438740
    87448741    int8_t value;
    … …  
    87958792        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    87968793
    8797     auto code = compile(proc);
     8794    auto code = compileProc(proc);
    87988795
    87998796    int8_t value;
    … …  
    88598856        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    88608857
    8861     auto code = compile(proc);
     8858    auto code = compileProc(proc);
    88628859
    88638860    int8_t value;
    … …  
    89408937        proc, Return, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 45));
    89418938
    8942     auto code = compile(proc);
     8939    auto code = compileProc(proc);
    89438940
    89448941    int8_t value;
    … …  
    89958992        root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
    89968993
    8997     auto code = compile(proc);
     8994    auto code = compileProc(proc);
    89988995
    89998996    CHECK(invoke<double>(*code, 0) == 42.0);
    … …  
    90319028        root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
    90329029
    9033     auto code = compile(proc);
     9030    auto code = compileProc(proc);
    90349031
    90359032    CHECK(invoke<double>(*code, 0) == 42.0);
    … …  
    90669063        root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
    90679064
    9068     auto code = compile(proc);
     9065    auto code = compileProc(proc);
    90699066
    90709067    CHECK(invoke<double>(*code, 0) == 42.0);
    … …  
    91039100        root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
    91049101
    9105     auto code = compile(proc);
     9102    auto code = compileProc(proc);
    91069103
    91079104    CHECK(invoke<double>(*code, 0, 42) == 42.0);
    … …  
    91369133        root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
    91379134
    9138     auto code = compile(proc);
     9135    auto code = compileProc(proc);
    91399136
    91409137    CHECK(invoke<double>(*code, 0ll, 42ll) == 42.0);
    … …  
    91579154    root->appendNewControlValue(proc, Return, Origin(), checkAdd);
    91589155
    9159     auto code = compile(proc);
     9156    auto code = compileProc(proc);
    91609157
    91619158    CHECK(invoke<int>(*code) == a + b);
    … …  
    91789175    root->appendNewControlValue(proc, Return, Origin(), checkAdd);
    91799176
    9180     auto code = compile(proc);
     9177    auto code = compileProc(proc);
    91819178
    91829179    CHECK(invoke<int>(*code) == 42);
    … …  
    92859282    root->appendNewControlValue(proc, Return, Origin(), checkAdd);
    92869283
    9287     auto code = compile(proc);
     9284    auto code = compileProc(proc);
    92889285
    92899286    CHECK(invoke<int64_t>(*code, 0ll) == 0);
    … …  
    93169313    root->appendNewControlValue(proc, Return, Origin(), checkAdd);
    93179314
    9318     auto code = compile(proc);
     9315    auto code = compileProc(proc);
    93199316
    93209317    CHECK(invoke<int32_t>(*code, 0ll) == 0);
    … …  
    93519348        root->appendNew<Value>(proc, IToD, Origin(), checkSub));
    93529349
    9353     auto code = compile(proc);
     9350    auto code = compileProc(proc);
    93549351
    93559352    CHECK(invoke<double>(*code, 0) == -42.0);
    … …  
    93939390        root->appendNew<Value>(proc, IToD, Origin(), checkSub));
    93949391
    9395     auto code = compile(proc);
     9392    auto code = compileProc(proc);
    93969393
    93979394    CHECK(invoke<double>(*code, 0) == -static_cast<double>(badImm));
    … …  
    94309427        root->appendNew<Value>(proc, IToD, Origin(), checkSub));
    94319428
    9432     auto code = compile(proc);
     9429    auto code = compileProc(proc);
    94339430
    94349431    CHECK(invoke<double>(*code, 0, 42) == -42.0);
    … …  
    94689465        root->appendNew<Value>(proc, IToD, Origin(), checkSub));
    94699466
    9470     auto code = compile(proc);
     9467    auto code = compileProc(proc);
    94719468
    94729469    CHECK(invoke<double>(*code, 0ll, 42ll) == -42.0);
    … …  
    94899486    root->appendNewControlValue(proc, Return, Origin(), checkSub);
    94909487
    9491     auto code = compile(proc);
     9488    auto code = compileProc(proc);
    94929489
    94939490    CHECK(invoke<int>(*code) == a - b);
    … …  
    95109507    root->appendNewControlValue(proc, Return, Origin(), checkSub);
    95119508
    9512     auto code = compile(proc);
     9509    auto code = compileProc(proc);
    95139510
    95149511    CHECK(invoke<int>(*code) == 42);
    … …  
    95399536        root->appendNew<Value>(proc, IToD, Origin(), checkNeg));
    95409537
    9541     auto code = compile(proc);
     9538    auto code = compileProc(proc);
    95429539
    95439540    CHECK(invoke<double>(*code, 0) == 0.0);
    … …  
    95699566        root->appendNew<Value>(proc, IToD, Origin(), checkNeg));
    95709567
    9571     auto code = compile(proc);
     9568    auto code = compileProc(proc);
    95729569
    95739570    CHECK(invoke<double>(*code, 0ll) == 0.0);
    … …  
    96069603        root->appendNew<Value>(proc, IToD, Origin(), checkMul));
    96079604
    9608     auto code = compile(proc);
     9605    auto code = compileProc(proc);
    96099606
    96109607    CHECK(invoke<double>(*code, 0, 42) == 0.0);
    … …  
    96479644        root->appendNew<Value>(proc, IToD, Origin(), checkMul));
    96489645
    9649     auto code = compile(proc);
     9646    auto code = compileProc(proc);
    96509647
    96519648    left = 0;
    … …  
    96949691        root->appendNew<Value>(proc, IToD, Origin(), checkMul));
    96959692
    9696     auto code = compile(proc);
     9693    auto code = compileProc(proc);
    96979694
    96989695    CHECK(invoke<double>(*code, 0) == 0.0);
    … …  
    97279724        root->appendNew<Value>(proc, IToD, Origin(), checkMul));
    97289725
    9729     auto code = compile(proc);
     9726    auto code = compileProc(proc);
    97309727
    97319728    CHECK(invoke<double>(*code, 0, 42) == 0.0);
    … …  
    97489745    root->appendNewControlValue(proc, Return, Origin(), checkMul);
    97499746
    9750     auto code = compile(proc);
     9747    auto code = compileProc(proc);
    97519748
    97529749    CHECK(invoke<int>(*code) == a * b);
    … …  
    97699766    root->appendNewControlValue(proc, Return, Origin(), checkMul);
    97709767
    9771     auto code = compile(proc);
     9768    auto code = compileProc(proc);
    97729769
    97739770    CHECK(invoke<int>(*code) == 42);
    … …  
    98859882        root->appendNew<Value>(proc, IToD, Origin(), checkMul));
    98869883
    9887     auto code = compile(proc);
     9884    auto code = compileProc(proc);
    98889885
    98899886    CHECK(invoke<double>(*code, 0ll, 42ll) == 0.0);
    … …  
    1073510732    }
    1073610733
    10737     auto code = compile(proc);
     10734    auto code = compileProc(proc);
    1073810735
    1073910736    for (unsigned i = 0; i < degree; ++i) {
    … …  
    1077810775    }
    1077910776
    10780     auto code = compile(proc);
     10777    auto code = compileProc(proc);
    1078110778
    1078210779    for (unsigned i = 0; i < degree; ++i) {
    … …  
    1081710814    switchValue->appendCase(SwitchCase(13, FrequentedBlock(otherTarget)));
    1081810815
    10819     auto code = compile(proc);
     10816    auto code = compileProc(proc);
    1082010817
    1082110818    for (unsigned i = 0; i < 20; ++i) {
    … …  
    1084510842    switchValue->appendCase(SwitchCase(13, FrequentedBlock(otherTarget)));
    1084610843
    10847     auto code = compile(proc);
     10844    auto code = compileProc(proc);
    1084810845
    1084910846    for (unsigned i = 0; i < 20; ++i) {
    … …  
    1120311200            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2)));
    1120411201
    11205     auto code = compile(proc);
     11202    auto code = compileProc(proc);
    1120611203    CHECK(invoke<intptr_t>(*code, 42, 1, 2) == 1);
    1120711204    CHECK(invoke<intptr_t>(*code, 42, 642462, 32533) == 642462);
    … …  
    1122211219            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2)));
    1122311220
    11224     auto code = compile(proc);
     11221    auto code = compileProc(proc);
    1122511222    CHECK(invoke<intptr_t>(*code, 42, 1, 2) == 1);
    1122611223    CHECK(invoke<intptr_t>(*code, 42, 642462, 32533) == 642462);
    … …  
    1124411241            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1)));
    1124511242
    11246     auto code = compile(proc);
     11243    auto code = compileProc(proc);
    1124711244    CHECK(invoke<intptr_t>(*code, -1.0, 1.0, 1, 2) == 1);
    1124811245    CHECK(invoke<intptr_t>(*code, 42.5, 42.51, 642462, 32533) == 642462);
    … …  
    1134111338            root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1)));
    1134211339
    11343     auto code = compile(proc);
     11340    auto code = compileProc(proc);
    1134411341    CHECK(invoke<double>(*code, 42, 1.5, 2.6) == 1.5);
    1134511342    CHECK(invoke<double>(*code, 42, 642462.7, 32533.8) == 642462.7);
    … …  
    1136011357            root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1)));
    1136111358
    11362     auto code = compile(proc);
     11359    auto code = compileProc(proc);
    1136311360    CHECK(invoke<double>(*code, 42, 1.5, 2.6) == 1.5);
    1136411361    CHECK(invoke<double>(*code, 42, 642462.7, 32533.8) == 642462.7);
    … …  
    1138211379            root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR3)));
    1138311380
    11384     auto code = compile(proc);
     11381    auto code = compileProc(proc);
    1138511382    CHECK(invoke<double>(*code, -1.0, 1.0, 1.1, 2.2) == 1.1);
    1138611383    CHECK(invoke<double>(*code, 42.5, 42.51, 642462.3, 32533.4) == 642462.3);
    … …  
    1146811465                arg2,
    1146911466                arg3));
    11470         auto code = compile(proc);
     11467        auto code = compileProc(proc);
    1147111468
    1147211469        for (auto& left : floatingPointOperands<double>()) {
    … …  
    1149511492
    1149611493        root->appendNewControlValue(proc, Return, Origin(), result);
    11497         auto code = compile(proc);
     11494        auto code = compileProc(proc);
    1149811495
    1149911496        for (auto& left : floatingPointOperands<double>()) {
    … …  
    1152211519
    1152311520        root->appendNewControlValue(proc, Return, Origin(), result);
    11524         auto code = compile(proc);
     11521        auto code = compileProc(proc);
    1152511522
    1152611523        for (auto& left : floatingPointOperands<double>()) {
    … …  
    1155011547
    1155111548        root->appendNewControlValue(proc, Return, Origin(), result);
    11552         auto code = compile(proc);
     11549        auto code = compileProc(proc);
    1155311550
    1155411551        for (auto& left : floatingPointOperands<double>()) {
    … …  
    1157611573                arg2,
    1157711574                arg0));
    11578         auto code = compile(proc);
     11575        auto code = compileProc(proc);
    1157911576
    1158011577        for (auto& left : floatingPointOperands<double>()) {
    … …  
    1160211599
    1160311600        root->appendNewControlValue(proc, Return, Origin(), result);
    11604         auto code = compile(proc);
     11601        auto code = compileProc(proc);
    1160511602
    1160611603        for (auto& left : floatingPointOperands<double>()) {
    … …  
    1165411651                arg2,
    1165511652                arg3));
    11656         auto code = compile(proc);
     11653        auto code = compileProc(proc);
    1165711654
    1165811655        for (auto& left : floatingPointOperands<float>()) {
    … …  
    1168911686
    1169011687        root->appendNewControlValue(proc, Return, Origin(), result);
    11691         auto code = compile(proc);
     11688        auto code = compileProc(proc);
    1169211689
    1169311690        for (auto& left : floatingPointOperands<float>()) {
    … …  
    1172411721
    1172511722        root->appendNewControlValue(proc, Return, Origin(), result);
    11726         auto code = compile(proc);
     11723        auto code = compileProc(proc);
    1172711724
    1172811725        for (auto& left : floatingPointOperands<float>()) {
    … …  
    1176011757
    1176111758        root->appendNewControlValue(proc, Return, Origin(), result);
    11762         auto code = compile(proc);
     11759        auto code = compileProc(proc);
    1176311760
    1176411761        for (auto& left : floatingPointOperands<float>()) {
    … …  
    1179211789                arg2,
    1179311790                arg0));
    11794         auto code = compile(proc);
     11791        auto code = compileProc(proc);
    1179511792
    1179611793        for (auto& left : floatingPointOperands<float>()) {
    … …  
    1182411821
    1182511822        root->appendNewControlValue(proc, Return, Origin(), result);
    11826         auto code = compile(proc);
     11823        auto code = compileProc(proc);
    1182711824
    1182811825        for (auto& left : floatingPointOperands<float>()) {
    … …  
    1186111858            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1)));
    1186211859
    11863     auto code = compile(proc);
     11860    auto code = compileProc(proc);
    1186411861    CHECK(invoke<intptr_t>(*code, 1, 2) == (value == 42 ? 1 : 2));
    1186511862    CHECK(invoke<intptr_t>(*code, 642462, 32533) == (value == 42 ? 642462 : 32533));
    … …  
    1188411881            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2)));
    1188511882
    11886     auto code = compile(proc);
     11883    auto code = compileProc(proc);
    1188711884    CHECK(invoke<intptr_t>(*code, 42, 1, 2) == 1);
    1188811885    CHECK(invoke<intptr_t>(*code, 42, 642462, 32533) == 642462);
    … …  
    1192711924        root->appendNew<Const32Value>(proc, Origin(), 0));
    1192811925
    11929     auto code = compile(proc);
     11926    auto code = compileProc(proc);
    1193011927    CHECK(generationCount == 1);
    1193111928    CHECK(invoke<int>(*code, true) == 0);
    … …  
    1199811995        root->appendNew<Const32Value>(proc, Origin(), 0));
    1199911996
    12000     auto code = compile(proc);
     11997    auto code = compileProc(proc);
    1200111998    CHECK(generationCount == 1);
    1200211999    CHECK(generationCount2 == 1);
    … …  
    1204412041        root->appendNew<Value>(proc, Add, Origin(), addValue, addValue2));
    1204512042
    12046     auto code = compile(proc);
     12043    auto code = compileProc(proc);
    1204712044    CHECK(generationCount == 1);
    1204812045    CHECK(invoke<int>(*code, true) == 0);
    … …  
    1245312450    loop->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loop));
    1245412451
    12455     compile(proc);
     12452    compileProc(proc);
    1245612453}
    1245712454
    … …  
    1247812475            proc, Equal, Origin(), arg, elseBlock->appendNew<ConstPtrValue>(proc, Origin(), 0)));
    1247912476
    12480     auto code = compile(proc);
     12477    auto code = compileProc(proc);
    1248112478    CHECK(invoke<intptr_t>(*code, 0) == 1);
    1248212479    CHECK(invoke<intptr_t>(*code, 1) == 0);
    … …  
    1249512492        root->appendNew<Value>(proc, Shl, Origin(), arg, arg));
    1249612493
    12497     auto code = compile(proc);
     12494    auto code = compileProc(proc);
    1249812495
    1249912496    auto check = [&] (int32_t value) {
    … …  
    1251812515        root->appendNew<Value>(proc, SShr, Origin(), arg, arg));
    1251912516
    12520     auto code = compile(proc);
     12517    auto code = compileProc(proc);
    1252112518
    1252212519    auto check = [&] (int32_t value) {
    … …  
    1254112538        root->appendNew<Value>(proc, ZShr, Origin(), arg, arg));
    1254212539
    12543     auto code = compile(proc);
     12540    auto code = compileProc(proc);
    1254412541
    1254512542    auto check = [&] (uint32_t value) {
    … …  
    1256312560            proc, Shl, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));
    1256412561
    12565     auto code = compile(proc);
     12562    auto code = compileProc(proc);
    1256612563
    1256712564    auto check = [&] (int64_t value) {
    … …  
    1258712584            proc, SShr, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));
    1258812585
    12589     auto code = compile(proc);
     12586    auto code = compileProc(proc);
    1259012587
    1259112588    auto check = [&] (int64_t value) {
    … …  
    1261112608            proc, ZShr, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));
    1261212609
    12613     auto code = compile(proc);
     12610    auto code = compileProc(proc);
    1261412611
    1261512612    auto check = [&] (uint64_t value) {
    … …  
    1264412641    root->appendNewControlValue(proc, Return, Origin(), patchpoint);
    1264512642
    12646     auto code = compile(proc);
     12643    auto code = compileProc(proc);
    1264712644    CHECK(numCalls == 1);
    1264812645    CHECK(invoke<double>(*code, 42.5) == 42.5);
    … …  
    1267712674    root->appendNewControlValue(proc, Return, Origin(), result);
    1267812675
    12679     auto code = compile(proc);
     12676    auto code = compileProc(proc);
    1268012677    CHECK(invoke<int64_t>(*code, 0xffffffff00000000) == 0);
    1268112678}
    … …  
    1273112728    tail->appendNewControlValue(proc, Return, Origin(), phi);
    1273212729
    12733     auto code = compile(proc);
     12730    auto code = compileProc(proc);
    1273412731    CHECK(invoke<uint64_t>(*code, 1, 0xffffffff00000000) == 0);
    1273512732    CHECK(invoke<uint64_t>(*code, 0, 0xffffffff00000000) == 0xffffffff00000000);
    … …  
    1281312810    root->appendNewControlValue(proc, Return, Origin(), secondPatchpoint);
    1281412811   
    12815     auto code = compile(proc);
     12812    auto code = compileProc(proc);
    1281612813    CHECK(invoke<uint64_t>(*code) == result);
    1281712814}
    … …  
    1298712984        stop->appendIntConstant(proc, Origin(), pointerType(), 0));
    1298812985   
    12989     auto interpreter = compile(proc);
     12986    auto interpreter = compileProc(proc);
    1299012987   
    1299112988    Vector<intptr_t> data;
    … …  
    1313713134    CCallHelpers jit;
    1313813135    generate(proc, jit);
    13139     LinkBuffer linkBuffer(*vm, jit, nullptr);
     13136    LinkBuffer linkBuffer(jit, nullptr);
    1314013137    CodeLocationLabel labelOne = linkBuffer.locationOf(proc.entrypointLabel(0));
    1314113138    CodeLocationLabel labelTwo = linkBuffer.locationOf(proc.entrypointLabel(1));
    … …  
    1317013167    CCallHelpers jit;
    1317113168    generate(proc, jit);
    13172     LinkBuffer linkBuffer(*vm, jit, nullptr);
     13169    LinkBuffer linkBuffer(jit, nullptr);
    1317313170    CodeLocationLabel labelOne = linkBuffer.locationOf(proc.entrypointLabel(0));
    1317413171    CodeLocationLabel labelTwo = linkBuffer.locationOf(proc.entrypointLabel(1));
    … …  
    1325713254    CCallHelpers jit;
    1325813255    generate(proc, jit);
    13259     LinkBuffer linkBuffer(*vm, jit, nullptr);
     13256    LinkBuffer linkBuffer(jit, nullptr);
    1326013257    CodeLocationLabel labelOne = linkBuffer.locationOf(proc.entrypointLabel(0));
    1326113258    CodeLocationLabel labelTwo = linkBuffer.locationOf(proc.entrypointLabel(1));
    … …  
    1337413371    CCallHelpers jit;
    1337513372    generate(proc, jit);
    13376     LinkBuffer linkBuffer(*vm, jit, nullptr);
     13373    LinkBuffer linkBuffer(jit, nullptr);
    1337713374    CodeLocationLabel labelOne = linkBuffer.locationOf(proc.entrypointLabel(0));
    1337813375    CodeLocationLabel labelTwo = linkBuffer.locationOf(proc.entrypointLabel(1));
    … …  
    1345213449    CCallHelpers jit;
    1345313450    generate(proc, jit);
    13454     LinkBuffer linkBuffer(*vm, jit, nullptr);
     13451    LinkBuffer linkBuffer(jit, nullptr);
    1345513452    CodeLocationLabel labelOne = linkBuffer.locationOf(proc.entrypointLabel(0));
    1345613453    CodeLocationLabel labelTwo = linkBuffer.locationOf(proc.entrypointLabel(1));
    … …  
    1350113498        root->appendNew<Value>(proc, Return, Origin(), patchpoint);
    1350213499       
    13503         compile(proc);
     13500        compileProc(proc);
    1350413501        CHECK(ranFirstPatchpoint);
    1350513502        CHECK(ranSecondPatchpoint);
    … …  
    1361513612    slowPath->appendNew<Value>(proc, Return, Origin(), slowPath->appendNew<Const32Value>(proc, Origin(), 20));
    1361613613   
    13617     auto code = compile(proc);
     13614    auto code = compileProc(proc);
    1361813615    CHECK_EQ(invoke<int>(*code), 10);
    1361913616}
    … …  
    1370313700    Options::maxB3TailDupBlockSuccessors() = 0;
    1370413701
    13705     auto code = compile(proc);
     13702    auto code = compileProc(proc);
    1370613703    CHECK_EQ(invoke<int>(*code, 1), 1);
    1370713704    CHECK_EQ(invoke<int>(*code, 0), 0);
    … …  
    1377713774    continuation->appendNew<Value>(proc, Return, Origin(), phi);
    1377813775   
    13779     auto code = compile(proc);
     13776    auto code = compileProc(proc);
    1378013777    CHECK_EQ(invoke<int>(*code, 0), 31);
    1378113778    CHECK_EQ(invoke<int>(*code, 1), 32);
    … …  
    1379513792    root->appendNew<Value>(proc, Return, Origin(), root->appendIntConstant(proc, Origin(), Int32, 42));
    1379613793   
    13797     auto code = compile(proc);
     13794    auto code = compileProc(proc);
    1379813795    CHECK_EQ(invoke<int>(*code), 42);
    1379913796    if (isX86())
    … …  
    1381413811    root->appendNew<Value>(proc, Return, Origin(), root->appendIntConstant(proc, Origin(), Int32, 42));
    1381513812   
    13816     auto code = compile(proc);
     13813    auto code = compileProc(proc);
    1381713814    CHECK_EQ(invoke<int>(*code), 42);
    1381813815    checkDoesNotUseInstruction(*code, "lock");
    … …  
    1383113828    root->appendNew<Value>(proc, Return, Origin(), root->appendIntConstant(proc, Origin(), Int32, 42));
    1383213829   
    13833     auto code = compile(proc);
     13830    auto code = compileProc(proc);
    1383413831    CHECK_EQ(invoke<int>(*code), 42);
    1383513832    checkDoesNotUseInstruction(*code, "lock");
    … …  
    1405614053    root->appendNew<Value>(proc, Return, Origin());
    1405714054
    14058     compile(proc);
     14055    compileProc(proc);
    1405914056}
    1406014057
    … …  
    1409114088            });
    1409214089        root->appendNew<Value>(proc, Return, Origin());
    14093         auto code = compile(proc);
     14090        auto code = compileProc(proc);
    1409414091        bool usesCSRs = false;
    1409514092        for (Air::BasicBlock* block : proc.code()) {
    … …  
    1413014127    root->appendNew<Value>(proc, Return, Origin(), result);
    1413114128   
    14132     auto code = compile(proc);
     14129    auto code = compileProc(proc);
    1413314130    checkUsesInstruction(*code, "lea 0x64(%rdi,%rsi,4), %rax");
    1413414131    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), (1 + (2 << 2)) + 100);
    … …  
    1415214149    root->appendNew<Value>(proc, Return, Origin(), result);
    1415314150   
    14154     auto code = compile(proc);
     14151    auto code = compileProc(proc);
    1415514152    checkUsesInstruction(*code, "lea 0x64(%rdi,%rsi,4), %rax");
    1415614153    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), (1 + (2 << 2)) + 100);
    … …  
    1417114168    root->appendNew<Value>(proc, Return, Origin(), result);
    1417214169   
    14173     auto code = compile(proc);
     14170    auto code = compileProc(proc);
    1417414171    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), (1 + 2) + 100);
    1417514172    checkDisassembly(
    … …  
    1419614193    root->appendNew<Value>(proc, Return, Origin(), result);
    1419714194   
    14198     auto code = compile(proc);
     14195    auto code = compileProc(proc);
    1419914196    checkUsesInstruction(*code, "lea (%rdi,%rsi,4), %rax");
    1420014197    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + (2 << 2));
    … …  
    1421514212    root->appendNew<Value>(proc, Return, Origin(), result);
    1421614213   
    14217     auto code = compile(proc);
     14214    auto code = compileProc(proc);
    1421814215    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + 2);
    1421914216    checkDisassembly(
    … …  
    1424014237    root->appendNew<Value>(proc, Return, Origin(), result);
    1424114238   
    14242     auto code = compile(proc);
     14239    auto code = compileProc(proc);
    1424314240    checkUsesInstruction(*code, "lea (%rdi,%rsi,2), %rax");
    1424414241    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + (2 << 1));
    … …  
    1425914256    root->appendNew<Value>(proc, Return, Origin(), result);
    1426014257   
    14261     auto code = compile(proc);
     14258    auto code = compileProc(proc);
    1426214259    checkUsesInstruction(*code, "lea (%rdi,%rsi,4), %rax");
    1426314260    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + (2 << 2));
    … …  
    1427814275    root->appendNew<Value>(proc, Return, Origin(), result);
    1427914276   
    14280     auto code = compile(proc);
     14277    auto code = compileProc(proc);
    1428114278    checkUsesInstruction(*code, "lea (%rdi,%rsi,8), %rax");
    1428214279    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + (2 << 3));
    … …  
    1429714294    root->appendNew<Value>(proc, Return, Origin(), result);
    1429814295   
    14299     auto code = compile(proc);
     14296    auto code = compileProc(proc);
    1430014297    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + (static_cast<intptr_t>(2) << static_cast<intptr_t>(32)));
    1430114298}
    … …  
    1431514312    root->appendNew<Value>(proc, Return, Origin(), result);
    1431614313   
    14317     auto code = compile(proc);
     14314    auto code = compileProc(proc);
    1431814315    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + 2);
    1431914316}
    … …  
    1433314330    root->appendNew<Value>(proc, Return, Origin(), result);
    1433414331   
    14335     auto code = compile(proc);
     14332    auto code = compileProc(proc);
    1433614333    CHECK_EQ(invoke<intptr_t>(*code, 1, 2), 1 + (2 << 1));
    1433714334}
    … …  
    1439714394                    root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1),
    1439814395                    root->appendNew<Const32Value>(proc, Origin(), 2)))));
    14399     auto code = compile(proc);
     14396    auto code = compileProc(proc);
    1440014397    if (isX86())
    1440114398        checkUsesInstruction(*code, "(%rdi,%rsi,4)");
    … …  
    1442114418                    root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1),
    1442214419                    root->appendNew<Const32Value>(proc, Origin(), 32)))));
    14423     auto code = compile(proc);
     14420    auto code = compileProc(proc);
    1442414421    int32_t value = 12341234;
    1442514422    char* ptr = bitwise_cast<char*>(&value);
    … …  
    1443814435    root->appendNew<Value>(proc, Return, Origin());
    1443914436   
    14440     auto code = compile(proc);
     14437    auto code = compileProc(proc);
    1444114438    bool found = false;
    1444214439    for (Air::BasicBlock* block : proc.code()) {
    … …  
    1449414491        done->appendNew<Value>(proc, Return, Origin());
    1449514492       
    14496         auto code = compile(proc);
     14493        auto code = compileProc(proc);
    1449714494        T value[2];
    1449814495        value[0] = 42;
    … …  
    1452514522        done->appendNew<Value>(proc, Return, Origin());
    1452614523       
    14527         auto code = compile(proc);
     14524        auto code = compileProc(proc);
    1452814525        T value[2];
    1452914526        value[0] = 42;
    … …  
    1455914556        fail->appendNew<Value>(proc, Return, Origin());
    1456014557       
    14561         auto code = compile(proc);
     14558        auto code = compileProc(proc);
    1456214559        T value[2];
    1456314560        value[0] = 42;
    … …  
    1460114598        fail->appendNew<Value>(proc, Return, Origin());
    1460214599       
    14603         auto code = compile(proc);
     14600        auto code = compileProc(proc);
    1460414601        T value[2];
    1460514602        value[0] = 42;
    … …  
    1462714624                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
    1462814625       
    14629         auto code = compile(proc);
     14626        auto code = compileProc(proc);
    1463014627        T value[2];
    1463114628        value[0] = 42;
    … …  
    1465614653                root->appendNew<Const32Value>(proc, Origin(), 0)));
    1465714654       
    14658         auto code = compile(proc);
     14655        auto code = compileProc(proc);
    1465914656        T value[2];
    1466014657        value[0] = 42;
    … …  
    1468314680                42));
    1468414681       
    14685         auto code = compile(proc);
     14682        auto code = compileProc(proc);
    1468614683        T value[2];
    1468714684        value[0] = 42;
    … …  
    1474714744        fail->appendNew<Value>(proc, Return, Origin());
    1474814745       
    14749         auto code = compile(proc);
     14746        auto code = compileProc(proc);
    1475014747        T value[2];
    1475114748        value[0] = 42;
    … …  
    1478814785        fail->appendNew<Value>(proc, Return, Origin());
    1478914786       
    14790         auto code = compile(proc);
     14787        auto code = compileProc(proc);
    1479114788        T value[2];
    1479214789        value[0] = 42;
    … …  
    1482914826        fail->appendNew<Value>(proc, Return, Origin());
    1483014827       
    14831         auto code = compile(proc);
     14828        auto code = compileProc(proc);
    1483214829        T value[2];
    1483314830        value[0] = 42;
    … …  
    1485414851                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
    1485514852       
    14856         auto code = compile(proc);
     14853        auto code = compileProc(proc);
    1485714854        T value[2];
    1485814855        value[0] = 42;
    … …  
    1488614883                root->appendIntConstant(proc, Origin(), type, 42)));
    1488714884       
    14888         auto code = compile(proc);
     14885        auto code = compileProc(proc);
    1488914886        T value[2];
    1489014887        value[0] = 42;
    … …  
    1491714914                root->appendNew<Const32Value>(proc, Origin(), 0)));
    1491814915           
    14919         auto code = compile(proc);
     14916        auto code = compileProc(proc);
    1492014917        T value[2];
    1492114918        value[0] = 42;
    … …  
    1499814995                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
    1499914996   
    15000         auto code = compile(proc);
     14997        auto code = compileProc(proc);
    1500114998        T value[2];
    1500214999        value[0] = 5;
    … …  
    1501815015                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
    1501915016   
    15020         auto code = compile(proc);
     15017        auto code = compileProc(proc);
    1502115018        T value[2];
    1502215019        value[0] = 5;
    … …  
    1503715034        root->appendNew<Value>(proc, Return, Origin());
    1503815035   
    15039         auto code = compile(proc);
     15036        auto code = compileProc(proc);
    1504015037        T value[2];
    1504115038        value[0] = 5;
    … …  
    1505715054        root->appendNew<Value>(proc, Return, Origin());
    1505815055   
    15059         auto code = compile(proc);
     15056        auto code = compileProc(proc);
    1506015057        T value[2];
    1506115058        value[0] = 5;
    … …  
    1509015087    values[1] = 0xbeef;
    1509115088   
    15092     auto code = compile(proc);
     15089    auto code = compileProc(proc);
    1509315090    if (isARM64())
    1509415091        checkUsesInstruction(*code, "eor");
    … …  
    1512015117    values[1] = 0xbeef;
    1512115118   
    15122     auto code = compile(proc);
     15119    auto code = compileProc(proc);
    1512315120    if (isARM64())
    1512415121        checkUsesInstruction(*code, "eor");
    … …  
    1515515152    root->appendNewControlValue(proc, Return, Origin(), result);
    1515615153
    15157     auto code = compile(proc);
     15154    auto code = compileProc(proc);
    1515815155    CHECK_EQ(invoke<int32_t>(*code, 1, 2 + offset), 0x42);
    1515915156    CHECK_EQ(invoke<int32_t>(*code, 3, 2 + offset), 42);
    … …  
    1520615203
    1520715204
    15208     auto code = compile(proc);
     15205    auto code = compileProc(proc);
    1520915206    invoke<void>(*code, loopCount, numToStore, values.data());
    1521015207    for (unsigned value : values)
    … …  
    1531915316{
    1532015317    JSC::initializeThreading();
    15321     vm = &VM::create(LargeHeap).leakRef();
    1532215318
    1532315319    Deque<RefPtr<SharedTask<void()>>> tasks;
    … …  
    1600015996    RUN(testAdd1(45));
    1600115997    RUN(testAdd1Ptr(51));
    16002     RUN(testAdd1Ptr(bitwise_cast<intptr_t>(vm)));
     15998    RUN(testAdd1Ptr(static_cast<intptr_t>(0xbaadbeef)));
    1600315999    RUN(testNeg32(52));
    1600416000    RUN(testNegPtr(53));
Note: See TracChangeset for help on using the changeset viewer.