X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/b80e619319b1def83d1e8b4f84042b661be1be7f..cb9aa2694aba0ae4f946ed34b8e0f6c99c1cfe44:/assembler/LinkBuffer.h diff --git a/assembler/LinkBuffer.h b/assembler/LinkBuffer.h index ae58946..516e456 100644 --- a/assembler/LinkBuffer.h +++ b/assembler/LinkBuffer.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009, 2010 Apple Inc. All rights reserved. + * Copyright (C) 2009, 2010, 2012, 2013, 2014 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -28,11 +28,24 @@ #if ENABLE(ASSEMBLER) -#include +#define DUMP_LINK_STATISTICS 0 +#define DUMP_CODE 0 + +#define GLOBAL_THUNK_ID reinterpret_cast(static_cast(-1)) +#define REGEXP_CODE_ID reinterpret_cast(static_cast(-2)) +#define CSS_CODE_ID reinterpret_cast(static_cast(-3)) + +#include "JITCompilationEffort.h" +#include "MacroAssembler.h" +#include +#include #include namespace JSC { +class CodeBlock; +class VM; + // LinkBuffer: // // This class assists in linking code generated by the macro assembler, once code generation @@ -47,55 +60,87 @@ namespace JSC { // * The address of a Label pointing into the code may be resolved. // * The value referenced by a DataLabel may be set. // -class LinkBuffer : public Noncopyable { +class LinkBuffer { + WTF_MAKE_NONCOPYABLE(LinkBuffer); WTF_MAKE_FAST_ALLOCATED; + typedef MacroAssemblerCodeRef CodeRef; typedef MacroAssemblerCodePtr CodePtr; typedef MacroAssembler::Label Label; typedef MacroAssembler::Jump Jump; + typedef MacroAssembler::PatchableJump PatchableJump; typedef MacroAssembler::JumpList JumpList; typedef MacroAssembler::Call Call; + typedef MacroAssembler::DataLabelCompact DataLabelCompact; typedef MacroAssembler::DataLabel32 DataLabel32; typedef MacroAssembler::DataLabelPtr DataLabelPtr; - typedef MacroAssembler::JmpDst JmpDst; + typedef MacroAssembler::ConvertibleLoadLabel ConvertibleLoadLabel; #if ENABLE(BRANCH_COMPACTION) typedef MacroAssembler::LinkRecord LinkRecord; typedef MacroAssembler::JumpLinkType JumpLinkType; #endif public: - // Note: Initialization sequence is significant, since executablePool is a PassRefPtr. - // First, executablePool is copied into m_executablePool, then the initialization of - // m_code uses m_executablePool, *not* executablePool, since this is no longer valid. - // The linkOffset parameter should only be non-null when recompiling for exception info - LinkBuffer(MacroAssembler* masm, PassRefPtr executablePool, void* linkOffset) - : m_executablePool(executablePool) - , m_size(0) + LinkBuffer(VM& vm, MacroAssembler& macroAssembler, void* ownerUID, JITCompilationEffort effort = JITCompilationMustSucceed) + : m_size(0) +#if ENABLE(BRANCH_COMPACTION) + , m_initialSize(0) +#endif + , m_didAllocate(false) , m_code(0) - , m_assembler(masm) + , m_vm(&vm) +#ifndef NDEBUG + , m_completed(false) +#endif + { + linkCode(macroAssembler, ownerUID, effort); + } + + LinkBuffer(VM& vm, MacroAssembler& macroAssembler, void* code, size_t size) + : m_size(size) +#if ENABLE(BRANCH_COMPACTION) + , m_initialSize(0) +#endif + , m_didAllocate(false) + , m_code(code) + , m_vm(&vm) #ifndef NDEBUG , m_completed(false) #endif { - linkCode(linkOffset); + linkCode(macroAssembler, 0, JITCompilationCanFail); } ~LinkBuffer() { - ASSERT(m_completed); + } + + bool didFailToAllocate() const + { + return !m_didAllocate; } + bool isValid() const + { + return !didFailToAllocate(); + } + // These methods are used to link or set values at code generation time. void link(Call call, FunctionPtr function) { ASSERT(call.isFlagSet(Call::Linkable)); - call.m_jmp = applyOffset(call.m_jmp); + call.m_label = applyOffset(call.m_label); MacroAssembler::linkCall(code(), call, function); } + void link(Call call, CodeLocationLabel label) + { + link(call, FunctionPtr(label.executableAddress())); + } + void link(Jump jump, CodeLocationLabel label) { - jump.m_jmp = applyOffset(jump.m_jmp); + jump.m_label = applyOffset(jump.m_label); MacroAssembler::linkJump(code(), jump, label); } @@ -107,30 +152,40 @@ public: void patch(DataLabelPtr label, void* value) { - JmpDst target = applyOffset(label.m_label); + AssemblerLabel target = applyOffset(label.m_label); MacroAssembler::linkPointer(code(), target, value); } void patch(DataLabelPtr label, CodeLocationLabel value) { - JmpDst target = applyOffset(label.m_label); + AssemblerLabel target = applyOffset(label.m_label); MacroAssembler::linkPointer(code(), target, value.executableAddress()); } // These methods are used to obtain handles to allow the code to be relinked / repatched later. + + CodeLocationLabel entrypoint() + { + return CodeLocationLabel(code()); + } CodeLocationCall locationOf(Call call) { ASSERT(call.isFlagSet(Call::Linkable)); ASSERT(!call.isFlagSet(Call::Near)); - return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_jmp))); + return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label))); } CodeLocationNearCall locationOfNearCall(Call call) { ASSERT(call.isFlagSet(Call::Linkable)); ASSERT(call.isFlagSet(Call::Near)); - return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_jmp))); + return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label))); + } + + CodeLocationLabel locationOf(PatchableJump jump) + { + return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(jump.m_jump.m_label))); } CodeLocationLabel locationOf(Label label) @@ -147,145 +202,148 @@ public: { return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label))); } + + CodeLocationDataLabelCompact locationOf(DataLabelCompact label) + { + return CodeLocationDataLabelCompact(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label))); + } + + CodeLocationConvertibleLoad locationOf(ConvertibleLoadLabel label) + { + return CodeLocationConvertibleLoad(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label))); + } // This method obtains the return address of the call, given as an offset from // the start of the code. unsigned returnAddressOffset(Call call) { - call.m_jmp = applyOffset(call.m_jmp); + call.m_label = applyOffset(call.m_label); return MacroAssembler::getLinkerCallReturnOffset(call); } - // Upon completion of all patching either 'finalizeCode()' or 'finalizeCodeAddendum()' should be called - // once to complete generation of the code. 'finalizeCode()' is suited to situations - // where the executable pool must also be retained, the lighter-weight 'finalizeCodeAddendum()' is - // suited to adding to an existing allocation. - CodeRef finalizeCode() + uint32_t offsetOf(Label label) { - performFinalization(); - - return CodeRef(m_code, m_executablePool, m_size); + return applyOffset(label.m_label).m_offset; } - CodeLocationLabel finalizeCodeAddendum() + unsigned offsetOf(PatchableJump jump) { - performFinalization(); - - return CodeLocationLabel(code()); + return applyOffset(jump.m_jump.m_label).m_offset; } + // Upon completion of all patching 'FINALIZE_CODE()' should be called once to + // complete generation of the code. Alternatively, call + // finalizeCodeWithoutDisassembly() directly if you have your own way of + // displaying disassembly. + + JS_EXPORT_PRIVATE CodeRef finalizeCodeWithoutDisassembly(); + JS_EXPORT_PRIVATE CodeRef finalizeCodeWithDisassembly(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3); + CodePtr trampolineAt(Label label) { return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label))); } + void* debugAddress() + { + return m_code; + } + + // FIXME: this does not account for the AssemblerData size! + size_t size() + { + return m_size; + } + private: +#if ENABLE(BRANCH_COMPACTION) + int executableOffsetFor(int location) + { + if (!location) + return 0; + return bitwise_cast(m_assemblerStorage.buffer())[location / sizeof(int32_t) - 1]; + } +#endif + template T applyOffset(T src) { #if ENABLE(BRANCH_COMPACTION) - src.m_offset -= m_assembler->executableOffsetFor(src.m_offset); + src.m_offset -= executableOffsetFor(src.m_offset); #endif return src; } - // Keep this private! - the underlying code should only be obtained externally via - // finalizeCode() or finalizeCodeAddendum(). + // Keep this private! - the underlying code should only be obtained externally via finalizeCode(). void* code() { return m_code; } + + void allocate(size_t initialSize, void* ownerUID, JITCompilationEffort); + void shrink(size_t newSize); - void linkCode(void* linkOffset) - { - UNUSED_PARAM(linkOffset); - ASSERT(!m_code); -#if !ENABLE(BRANCH_COMPACTION) - m_code = m_assembler->m_assembler.executableCopy(m_executablePool.get()); - m_size = m_assembler->size(); -#else - size_t initialSize = m_assembler->size(); - m_code = (uint8_t*)m_executablePool->alloc(initialSize); - if (!m_code) - return; - ExecutableAllocator::makeWritable(m_code, m_assembler->size()); - uint8_t* inData = (uint8_t*)m_assembler->unlinkedCode(); - uint8_t* outData = reinterpret_cast(m_code); - const uint8_t* linkBase = linkOffset ? reinterpret_cast(linkOffset) : outData; - int readPtr = 0; - int writePtr = 0; - Vector& jumpsToLink = m_assembler->jumpsToLink(); - unsigned jumpCount = jumpsToLink.size(); - for (unsigned i = 0; i < jumpCount; ++i) { - int offset = readPtr - writePtr; - ASSERT(!(offset & 1)); - - // Copy the instructions from the last jump to the current one. - size_t regionSize = jumpsToLink[i].from() - readPtr; - memcpy(outData + writePtr, inData + readPtr, regionSize); - m_assembler->recordLinkOffsets(readPtr, jumpsToLink[i].from(), offset); - readPtr += regionSize; - writePtr += regionSize; - - // Calculate absolute address of the jump target, in the case of backwards - // branches we need to be precise, forward branches we are pessimistic - const uint8_t* target; - if (jumpsToLink[i].to() >= jumpsToLink[i].from()) - target = linkBase + jumpsToLink[i].to() - offset; // Compensate for what we have collapsed so far - else - target = linkBase + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to()); - - JumpLinkType jumpLinkType = m_assembler->computeJumpType(jumpsToLink[i], linkBase + writePtr, target); - // Compact branch if we can... - if (m_assembler->canCompact(jumpsToLink[i].type())) { - // Step back in the write stream - int32_t delta = m_assembler->jumpSizeDelta(jumpsToLink[i].type(), jumpLinkType); - if (delta) { - writePtr -= delta; - m_assembler->recordLinkOffsets(jumpsToLink[i].from() - delta, readPtr, readPtr - writePtr); - } - } - jumpsToLink[i].setFrom(writePtr); - } - // Copy everything after the last jump - memcpy(outData + writePtr, inData + readPtr, m_assembler->size() - readPtr); - m_assembler->recordLinkOffsets(readPtr, m_assembler->size(), readPtr - writePtr); - - // Actually link everything (don't link if we've be given a linkoffset as it's a - // waste of time: linkOffset is used for recompiling to get exception info) - if (!linkOffset) { - for (unsigned i = 0; i < jumpCount; ++i) { - uint8_t* location = outData + jumpsToLink[i].from(); - uint8_t* target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to()); - m_assembler->link(jumpsToLink[i], location, target); - } - } - - jumpsToLink.clear(); - m_size = writePtr + m_assembler->size() - readPtr; - m_executablePool->tryShrink(m_code, initialSize, m_size); -#endif - } - - void performFinalization() - { -#ifndef NDEBUG - ASSERT(!m_completed); - m_completed = true; + JS_EXPORT_PRIVATE void linkCode(MacroAssembler&, void* ownerUID, JITCompilationEffort); +#if ENABLE(BRANCH_COMPACTION) + template + void copyCompactAndLinkCode(MacroAssembler&, void* ownerUID, JITCompilationEffort); #endif - ExecutableAllocator::makeExecutable(code(), m_size); - ExecutableAllocator::cacheFlush(code(), m_size); - } + void performFinalization(); - RefPtr m_executablePool; +#if DUMP_LINK_STATISTICS + static void dumpLinkStatistics(void* code, size_t initialSize, size_t finalSize); +#endif + +#if DUMP_CODE + static void dumpCode(void* code, size_t); +#endif + + RefPtr m_executableMemory; size_t m_size; +#if ENABLE(BRANCH_COMPACTION) + size_t m_initialSize; + AssemblerData m_assemblerStorage; +#endif + bool m_didAllocate; void* m_code; - MacroAssembler* m_assembler; + VM* m_vm; #ifndef NDEBUG bool m_completed; #endif }; +#define FINALIZE_CODE_IF(condition, linkBufferReference, dataLogFArgumentsForHeading) \ + (UNLIKELY((condition)) \ + ? ((linkBufferReference).finalizeCodeWithDisassembly dataLogFArgumentsForHeading) \ + : (linkBufferReference).finalizeCodeWithoutDisassembly()) + +bool shouldShowDisassemblyFor(CodeBlock*); + +#define FINALIZE_CODE_FOR(codeBlock, linkBufferReference, dataLogFArgumentsForHeading) \ + FINALIZE_CODE_IF(shouldShowDisassemblyFor(codeBlock), linkBufferReference, dataLogFArgumentsForHeading) + +// Use this to finalize code, like so: +// +// CodeRef code = FINALIZE_CODE(linkBuffer, ("my super thingy number %d", number)); +// +// Which, in disassembly mode, will print: +// +// Generated JIT code for my super thingy number 42: +// Code at [0x123456, 0x234567]: +// 0x123456: mov $0, 0 +// 0x12345a: ret +// +// ... and so on. +// +// Note that the dataLogFArgumentsForHeading are only evaluated when showDisassembly +// is true, so you can hide expensive disassembly-only computations inside there. + +#define FINALIZE_CODE(linkBufferReference, dataLogFArgumentsForHeading) \ + FINALIZE_CODE_IF(JSC::Options::showDisassembly(), linkBufferReference, dataLogFArgumentsForHeading) + +#define FINALIZE_DFG_CODE(linkBufferReference, dataLogFArgumentsForHeading) \ + FINALIZE_CODE_IF((JSC::Options::showDisassembly() || Options::showDFGDisassembly()), linkBufferReference, dataLogFArgumentsForHeading) + } // namespace JSC #endif // ENABLE(ASSEMBLER)