ftl/FTLLink.cpp

   1 /*
   2  * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "FTLLink.h"
  28
  29 #if ENABLE(FTL_JIT)
  30
  31 #include "ArityCheckFailReturnThunks.h"
  32 #include "CCallHelpers.h"
  33 #include "CodeBlockWithJITType.h"
  34 #include "DFGCommon.h"
  35 #include "FTLJITCode.h"
  36 #include "JITOperations.h"
  37 #include "JITStubs.h"
  38 #include "LLVMAPI.h"
  39 #include "LinkBuffer.h"
  40 #include "JSCInlines.h"
  41 #include "ProfilerCompilation.h"
  42 #include "VirtualRegister.h"
  43
  44 namespace JSC { namespace FTL {
  45
  46 using namespace DFG;
  47
  48 void link(State& state)
  49 {
  50     Graph& graph = state.graph;
  51     CodeBlock* codeBlock = graph.m_codeBlock;
  52     VM& vm = graph.m_vm;
  53
  54     // LLVM will create its own jump tables as needed.
  55     codeBlock->clearSwitchJumpTables();
  56
  57     // FIXME: Need to know the real frame register count.
  58     // https://bugs.webkit.org/show_bug.cgi?id=125727
  59     state.jitCode->common.frameRegisterCount = 1000;
  60
  61     state.jitCode->common.requiredRegisterCountForExit = graph.requiredRegisterCountForExit();
  62
  63     if (!graph.m_plan.inlineCallFrames->isEmpty())
  64         state.jitCode->common.inlineCallFrames = graph.m_plan.inlineCallFrames;
  65
  66     // Create the entrypoint. Note that we use this entrypoint totally differently
  67     // depending on whether we're doing OSR entry or not.
  68     CCallHelpers jit(&vm, codeBlock);
  69
  70     OwnPtr<LinkBuffer> linkBuffer;
  71
  72     CCallHelpers::Address frame = CCallHelpers::Address(
  73         CCallHelpers::stackPointerRegister, -static_cast<int32_t>(AssemblyHelpers::prologueStackPointerDelta()));
  74
  75     if (Profiler::Compilation* compilation = graph.compilation()) {
  76         compilation->addDescription(
  77             Profiler::OriginStack(),
  78             toCString("Generated FTL JIT code for ", CodeBlockWithJITType(codeBlock, JITCode::FTLJIT), ", instruction count = ", graph.m_codeBlock->instructionCount(), ":\n"));
  79
  80         graph.m_dominators.computeIfNecessary(graph);
  81         graph.m_naturalLoops.computeIfNecessary(graph);
  82
  83         const char* prefix = "    ";
  84
  85         DumpContext dumpContext;
  86         StringPrintStream out;
  87         Node* lastNode = 0;
  88         for (size_t blockIndex = 0; blockIndex < graph.numBlocks(); ++blockIndex) {
  89             BasicBlock* block = graph.block(blockIndex);
  90             if (!block)
  91                 continue;
  92
  93             graph.dumpBlockHeader(out, prefix, block, Graph::DumpLivePhisOnly, &dumpContext);
  94             compilation->addDescription(Profiler::OriginStack(), out.toCString());
  95             out.reset();
  96
  97             for (size_t nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
  98                 Node* node = block->at(nodeIndex);
  99                 if (!node->willHaveCodeGenOrOSR() && !Options::showAllDFGNodes())
 100                     continue;
 101
 102                 Profiler::OriginStack stack;
 103
 104                 if (node->origin.semantic.isSet()) {
 105                     stack = Profiler::OriginStack(
 106                         *vm.m_perBytecodeProfiler, codeBlock, node->origin.semantic);
 107                 }
 108
 109                 if (graph.dumpCodeOrigin(out, prefix, lastNode, node, &dumpContext)) {
 110                     compilation->addDescription(stack, out.toCString());
 111                     out.reset();
 112                 }
 113
 114                 graph.dump(out, prefix, node, &dumpContext);
 115                 compilation->addDescription(stack, out.toCString());
 116                 out.reset();
 117
 118                 if (node->origin.semantic.isSet())
 119                     lastNode = node;
 120             }
 121         }
 122
 123         dumpContext.dump(out, prefix);
 124         compilation->addDescription(Profiler::OriginStack(), out.toCString());
 125         out.reset();
 126
 127         out.print("    Disassembly:\n");
 128         for (unsigned i = 0; i < state.jitCode->handles().size(); ++i) {
 129             if (state.codeSectionNames[i] != "__text")
 130                 continue;
 131
 132                 ExecutableMemoryHandle* handle = state.jitCode->handles()[i].get();
 133                 disassemble(
 134                     MacroAssemblerCodePtr(handle->start()), handle->sizeInBytes(),
 135                     "      ", out, LLVMSubset);
 136         }
 137         compilation->addDescription(Profiler::OriginStack(), out.toCString());
 138         out.reset();
 139
 140         state.jitCode->common.compilation = compilation;
 141     }
 142
 143     switch (graph.m_plan.mode) {
 144     case FTLMode: {
 145         CCallHelpers::JumpList mainPathJumps;
 146
 147         jit.load32(
 148             frame.withOffset(sizeof(Register) * JSStack::ArgumentCount),
 149             GPRInfo::regT1);
 150         mainPathJumps.append(jit.branch32(
 151             CCallHelpers::AboveOrEqual, GPRInfo::regT1,
 152             CCallHelpers::TrustedImm32(codeBlock->numParameters())));
 153         jit.emitFunctionPrologue();
 154         jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 155         jit.store32(
 156             CCallHelpers::TrustedImm32(CallFrame::Location::encodeAsBytecodeOffset(0)),
 157             CCallHelpers::tagFor(JSStack::ArgumentCount));
 158         jit.storePtr(GPRInfo::callFrameRegister, &vm.topCallFrame);
 159         CCallHelpers::Call callArityCheck = jit.call();
 160 #if !ASSERT_DISABLED
 161         // FIXME: need to make this call register with exception handling somehow. This is
 162         // part of a bigger problem: FTL should be able to handle exceptions.
 163         // https://bugs.webkit.org/show_bug.cgi?id=113622
 164         // Until then, use a JIT ASSERT.
 165         jit.load64(vm.addressOfException(), GPRInfo::regT1);
 166         jit.jitAssertIsNull(GPRInfo::regT1);
 167 #endif
 168         jit.move(GPRInfo::returnValueGPR, GPRInfo::regT0);
 169         jit.emitFunctionEpilogue();
 170         mainPathJumps.append(jit.branchTest32(CCallHelpers::Zero, GPRInfo::regT0));
 171         jit.emitFunctionPrologue();
 172         jit.move(CCallHelpers::TrustedImmPtr(vm.arityCheckFailReturnThunks->returnPCsFor(vm, codeBlock->numParameters())), GPRInfo::regT7);
 173         jit.loadPtr(CCallHelpers::BaseIndex(GPRInfo::regT7, GPRInfo::regT0, CCallHelpers::timesPtr()), GPRInfo::regT7);
 174         CCallHelpers::Call callArityFixup = jit.call();
 175         jit.emitFunctionEpilogue();
 176         mainPathJumps.append(jit.jump());
 177
 178         linkBuffer = adoptPtr(new LinkBuffer(vm, jit, codeBlock, JITCompilationMustSucceed));
 179         linkBuffer->link(callArityCheck, codeBlock->m_isConstructor ? operationConstructArityCheck : operationCallArityCheck);
 180         linkBuffer->link(callArityFixup, FunctionPtr((vm.getCTIStub(arityFixup)).code().executableAddress()));
 181         linkBuffer->link(mainPathJumps, CodeLocationLabel(bitwise_cast<void*>(state.generatedFunction)));
 182
 183         state.jitCode->initializeAddressForCall(MacroAssemblerCodePtr(bitwise_cast<void*>(state.generatedFunction)));
 184         break;
 185     }
 186
 187     case FTLForOSREntryMode: {
 188         // We jump to here straight from DFG code, after having boxed up all of the
 189         // values into the scratch buffer. Everything should be good to go - at this
 190         // point we've even done the stack check. Basically we just have to make the
 191         // call to the LLVM-generated code.
 192         CCallHelpers::Label start = jit.label();
 193         jit.emitFunctionEpilogue();
 194         CCallHelpers::Jump mainPathJump = jit.jump();
 195
 196         linkBuffer = adoptPtr(new LinkBuffer(vm, jit, codeBlock, JITCompilationMustSucceed));
 197         linkBuffer->link(mainPathJump, CodeLocationLabel(bitwise_cast<void*>(state.generatedFunction)));
 198
 199         state.jitCode->initializeAddressForCall(linkBuffer->locationOf(start));
 200         break;
 201     }
 202
 203     default:
 204         RELEASE_ASSERT_NOT_REACHED();
 205         break;
 206     }
 207
 208     state.finalizer->entrypointLinkBuffer = linkBuffer.release();
 209     state.finalizer->function = state.generatedFunction;
 210     state.finalizer->jitCode = state.jitCode;
 211 }
 212
 213 } } // namespace JSC::FTL
 214
 215 #endif // ENABLE(FTL_JIT)
 216