2013-03-31  Filip Pizlo  <fpizlo@apple.com>

        fourthTier: FTL JIT should supply TBAA meta-data to LLVM

        https://bugs.webkit.org/show_bug.cgi?id=113656

        Reviewed by NOBODY (OOPS!).

        This adds support for performing strong typing on the LLVM IR that the FTL

        generates, by using TBAA meta-data. This will permit LLVM to do aggressive

        GVN, load elimination, and LICM optimization even if it sees pointer store

        side-effects. The goal is to precisely model all loads and stores we emit,

        except for the super crazy ones (GetById that can go all-out polymorphic,

        or for example a Call where we know nothing).

        This is accomplished by introducing the notion of an AbstractHeap

        typesystem. An AbstractHeap is a subset of all possible memory locations

        that we might store to. For example, JSCell::m_structure and

        JSObject::m_butterfly are two disjoint AbstractHeaps because we know that

        a store to one cannot clobber the other. AbstractHeaps follow a

        single-inheritance hierarchy. There is the root heap, which corresponds to

        any possible memory location accessible to the JS engine, and then there

        are heaps for all internal object fields, a heap for each global object,

        and so on.

        There are three other tidbits here that make this somewhat more interesting.

        We have a notion of an AbstractHeap-with-offset, called AbstractField.

        JSCell::m_structure is actually an AbstractField. This allows us to say

        things like m_out.loadPtr(base, m_heaps.JSCell_structure); this both

        gives you the offset of JSCell::m_structure and ascribes TBAA meta-data for

        the JSCell::m_structure heap to the generated load instrction.

        Another fun tidbit is the notion of Indexed, Numbered, and Absolute abstract

        heaps. An indexed abstract heap corresponds to a set of locations that you

        might access by index from some base. Virtual registers are a great example.

        Though I call them just "variables" in the FTL. When we access a virtual

        register, we know that we aren't interfering with accesses to

        Structure-managed named properties, or with JSCell::m_structure, or with

        other such disjoint heaps. But we also know that if we access a variable at

        offset X and then another variable at offset Y and we know that X and Y are

        unequal, then these two accesses are on disjoint subheaps of the variables

        heap. This works out naturally for interference between, say, scoped variable

        access and local variable access: if you access scoped variable r5 and then

        access a local variable r5, these might interfere - and they will get the

        same abstract subheap of the variables heap. IndexedAbstractHeaps

        conveniently remember the size of the elements and will give you an

        AbstractField (i.e. heap-with-offset) if you give it an index. This is great

        for conveniently writing code that accesses contiguous arrays of well-typed

        things. This allows you to literally do things like

        m_out.load64(callFrameRegister, m_heaps.variables[operand]) and the right

        thing will happen. You can also get the heap variables.atAnyIndex(), if

        you're doing an access with an unknown index.

        Numbered and Absolute abstract heaps are related except that they don't

        assume that the value used to get the abstract subheap corresponds to any

        meaningful offset from any base. Numbered heaps, like the properties heap

        (for named properties tracked by Structure), are "numbered" (not indexed)

        by the propertyNumber. So you can emit a GetByOffset by separately

        computing the offset and the propertyNumber (both values are stored in the

        StorageAccessData), and passing the offset directly to Output::address()

        and passing m_heaps.properties[propertyNumber] as the field. Absolute heaps

        are similar, but are keyed on absolute address. This is appropriate for

        global variables, and possibly other things.

        Finally, FTL::Output understands the notion of a pointer-with-TBAA-data,

        and calls it a TypedPointer. TypedPointer is a tuple of a LLVMValueRef

        referencing an intptr value and a pointer to an AbstractHeap. All load()

        and store() operations now take a TypedPointer, and will perform the access

        by casting the intptr to a pointer of the right type and then ascribing the

        TBAA meta-data from the AbstractHeap.

        * JavaScriptCore.xcodeproj/project.pbxproj:

        * ftl/FTLAbbreviations.h:

        (JSC::FTL::mdKindID):

        (JSC::FTL::mdString):

        (JSC::FTL::mdNode):

        (FTL):

        (JSC::FTL::setMetadata):

        * ftl/FTLAbstractHeap.cpp: Added.

        (FTL):

        (JSC::FTL::AbstractHeap::tbaaMetadataSlow):

        (JSC::FTL::AbstractHeap::decorateInstruction):

        (JSC::FTL::IndexedAbstractHeap::IndexedAbstractHeap):

        (JSC::FTL::IndexedAbstractHeap::~IndexedAbstractHeap):

        (JSC::FTL::IndexedAbstractHeap::atSlow):

        (JSC::FTL::IndexedAbstractHeap::initialize):

        (JSC::FTL::NumberedAbstractHeap::NumberedAbstractHeap):

        (JSC::FTL::NumberedAbstractHeap::~NumberedAbstractHeap):

        (JSC::FTL::AbsoluteAbstractHeap::AbsoluteAbstractHeap):

        (JSC::FTL::AbsoluteAbstractHeap::~AbsoluteAbstractHeap):

        * ftl/FTLAbstractHeap.h: Added.

        (FTL):

        (AbstractHeap):

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

        (JSC::FTL::AbstractHeap::isInitialized):

        (JSC::FTL::AbstractHeap::initialize):

        (JSC::FTL::AbstractHeap::parent):

        (JSC::FTL::AbstractHeap::heapName):

        (JSC::FTL::AbstractHeap::tbaaMetadata):

        (AbstractField):

        (JSC::FTL::AbstractField::AbstractField):

        (JSC::FTL::AbstractField::initialize):

        (JSC::FTL::AbstractField::offset):

        (IndexedAbstractHeap):

        (JSC::FTL::IndexedAbstractHeap::atAnyIndex):

        (JSC::FTL::IndexedAbstractHeap::at):

        (JSC::FTL::IndexedAbstractHeap::operator[]):

        (JSC::FTL::IndexedAbstractHeap::returnInitialized):

        (JSC::FTL::IndexedAbstractHeap::MyHashTraits::constructDeletedValue):

        (JSC::FTL::IndexedAbstractHeap::MyHashTraits::isDeletedValue):

        (NumberedAbstractHeap):

        (JSC::FTL::NumberedAbstractHeap::atAnyNumber):

        (JSC::FTL::NumberedAbstractHeap::at):

        (JSC::FTL::NumberedAbstractHeap::operator[]):

        (AbsoluteAbstractHeap):

        (JSC::FTL::AbsoluteAbstractHeap::atAnyAddress):

        (JSC::FTL::AbsoluteAbstractHeap::at):

        (JSC::FTL::AbsoluteAbstractHeap::operator[]):

        * ftl/FTLAbstractHeapRepository.cpp: Added.

        (FTL):

        (JSC::FTL::AbstractHeapRepository::AbstractHeapRepository):

        (JSC::FTL::AbstractHeapRepository::~AbstractHeapRepository):

        * ftl/FTLAbstractHeapRepository.h: Added.

        (FTL):

        (AbstractHeapRepository):

        * ftl/FTLLowerDFGToLLVM.cpp:

        (JSC::FTL::LowerDFGToLLVM::lower):

        (JSC::FTL::LowerDFGToLLVM::addressFor):

        (JSC::FTL::LowerDFGToLLVM::payloadFor):

        (JSC::FTL::LowerDFGToLLVM::tagFor):

        (LowerDFGToLLVM):

        * ftl/FTLOutput.h:

        (FTL):

        (JSC::FTL::Output::Output):

        (JSC::FTL::Output::initialize):

        (JSC::FTL::Output::set):

        (JSC::FTL::Output::load):

        (JSC::FTL::Output::store):

        (Output):

        (JSC::FTL::Output::load32):

        (JSC::FTL::Output::load64):

        (JSC::FTL::Output::loadPtr):

        (JSC::FTL::Output::store32):

        (JSC::FTL::Output::store64):

        (JSC::FTL::Output::storePtr):

        (JSC::FTL::Output::address):

        * ftl/FTLTypedPointer.h: Added.

        (FTL):

        (TypedPointer):

        (JSC::FTL::TypedPointer::TypedPointer):

        (JSC::FTL::TypedPointer::operator!):

        (JSC::FTL::TypedPointer::heap):

        (JSC::FTL::TypedPointer::value):

        * runtime/Options.h:

        (JSC):

		0FEA0A1C1708B00700BB722C /* FTLAbstractHeap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FEA0A171708B00700BB722C /* FTLAbstractHeap.cpp */; };

		0FEA0A1D1708B00700BB722C /* FTLAbstractHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FEA0A181708B00700BB722C /* FTLAbstractHeap.h */; settings = {ATTRIBUTES = (Private, ); }; };

		0FEA0A1E1708B00700BB722C /* FTLAbstractHeapRepository.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FEA0A191708B00700BB722C /* FTLAbstractHeapRepository.cpp */; };

		0FEA0A1F1708B00700BB722C /* FTLAbstractHeapRepository.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FEA0A1A1708B00700BB722C /* FTLAbstractHeapRepository.h */; settings = {ATTRIBUTES = (Private, ); }; };

		0FEA0A201708B00700BB722C /* FTLTypedPointer.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FEA0A1B1708B00700BB722C /* FTLTypedPointer.h */; };

		0FEA0A171708B00700BB722C /* FTLAbstractHeap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FTLAbstractHeap.cpp; path = ftl/FTLAbstractHeap.cpp; sourceTree = "<group>"; };

		0FEA0A181708B00700BB722C /* FTLAbstractHeap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLAbstractHeap.h; path = ftl/FTLAbstractHeap.h; sourceTree = "<group>"; };

		0FEA0A191708B00700BB722C /* FTLAbstractHeapRepository.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FTLAbstractHeapRepository.cpp; path = ftl/FTLAbstractHeapRepository.cpp; sourceTree = "<group>"; };

		0FEA0A1A1708B00700BB722C /* FTLAbstractHeapRepository.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLAbstractHeapRepository.h; path = ftl/FTLAbstractHeapRepository.h; sourceTree = "<group>"; };

		0FEA0A1B1708B00700BB722C /* FTLTypedPointer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLTypedPointer.h; path = ftl/FTLTypedPointer.h; sourceTree = "<group>"; };

				0FEA0A171708B00700BB722C /* FTLAbstractHeap.cpp */,

				0FEA0A181708B00700BB722C /* FTLAbstractHeap.h */,

				0FEA0A191708B00700BB722C /* FTLAbstractHeapRepository.cpp */,

				0FEA0A1A1708B00700BB722C /* FTLAbstractHeapRepository.h */,

				0FEA0A1B1708B00700BB722C /* FTLTypedPointer.h */,

				0FEA0A1D1708B00700BB722C /* FTLAbstractHeap.h in Headers */,

				0FEA0A1F1708B00700BB722C /* FTLAbstractHeapRepository.h in Headers */,

				0FEA0A201708B00700BB722C /* FTLTypedPointer.h in Headers */,

				0FEA0A1E1708B00700BB722C /* FTLAbstractHeapRepository.cpp in Sources */,

				0FEA0A1C1708B00700BB722C /* FTLAbstractHeap.cpp in Sources */,

static inline unsigned mdKindID(const char* string) { return LLVMGetMDKindID(string, strlen(string)); }

static inline LValue mdString(const char* string, unsigned length) { return LLVMMDString(string, length); }

static inline LValue mdString(const char* string) { return mdString(string, strlen(string)); }

static inline LValue mdNode(LValue* args, unsigned numArgs) { return LLVMMDNode(args, numArgs); }

static inline LValue mdNode() { return mdNode(0, 0); }

static inline LValue mdNode(LValue arg1) { return mdNode(&arg1, 1); }

static inline LValue mdNode(LValue arg1, LValue arg2)

{

    LValue args[] = { arg1, arg2 };

    return mdNode(args, 2);

}

static inline void setMetadata(LValue instruction, unsigned kind, LValue metadata) { LLVMSetMetadata(instruction, kind, metadata); }

/*

 * Copyright (C) 2013 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "FTLAbstractHeap.h"

#if ENABLE(FTL_JIT)

#include "FTLAbbreviations.h"

#include "FTLAbstractHeapRepository.h"

#include "Options.h"

namespace JSC { namespace FTL {

LValue AbstractHeap::tbaaMetadataSlow(const AbstractHeapRepository& repository) const

{

    m_tbaaMetadata = mdNode(mdString(m_heapName), m_parent->tbaaMetadata(repository));

    return m_tbaaMetadata;

}

void AbstractHeap::decorateInstruction(LValue instruction, const AbstractHeapRepository& repository) const

{

    if (!Options::useFTLTBAA())

        return;

    setMetadata(instruction, repository.m_tbaaKind, tbaaMetadata(repository));

}

IndexedAbstractHeap::IndexedAbstractHeap(AbstractHeap* parent, const char* heapName, size_t elementSize)

    : m_heapForAnyIndex(parent, heapName)

    , m_heapNameLength(strlen(heapName))

    , m_elementSize(elementSize)

{

}

IndexedAbstractHeap::~IndexedAbstractHeap()

{

}

const AbstractField& IndexedAbstractHeap::atSlow(ptrdiff_t index)

{

    ASSERT(static_cast<size_t>(index) >= m_smallIndices.size());

    if (UNLIKELY(!m_largeIndices))

        m_largeIndices = adoptPtr(new MapType());

    MapType::const_iterator iter = m_largeIndices->find(index);

    if (iter != m_largeIndices->end())

        return *iter->value;

    OwnPtr<AbstractField> field = adoptPtr(new AbstractField());

    AbstractField* result = field.get();

    initialize(*result, index);

    m_largeIndices->add(index, field.release());

    return *result;

}

void IndexedAbstractHeap::initialize(AbstractField& field, ptrdiff_t signedIndex)

{

    // Build up a name of the form:

    //

    //    heapName_hexIndex

    //

    // or:

    //

    //    heapName_neg_hexIndex

    //

    // For example if you access an indexed heap called FooBar at index 5, you'll

    // get:

    //

    //    FooBar_5

    //

    // Or if you access an indexed heap called Blah at index -10, you'll get:

    //

    //    Blah_neg_A

    //

    // This is important because LLVM uses the string to distinguish the types.

    bool negative;

    size_t index;

    if (signedIndex < 0) {

        negative = true;

        index = -signedIndex;

    } else {

        negative = false;

        index = signedIndex;

    }

    for (unsigned power = 4; power <= sizeof(void*) * 8; power += 4) {

        // The crazy way of testing of index >= 2 ** power

        // (where I use ** to denote pow()).

        if ((index >> 1) >> (power - 1))

            continue;

        unsigned numHexlets = power >> 2;

        size_t stringLength = m_heapNameLength + (negative ? 5 : 1) + numHexlets;

        char* characters;

        m_largeIndexNames.append(CString::newUninitialized(stringLength, characters));

        memcpy(characters, m_heapForAnyIndex.heapName(), m_heapNameLength);

        if (negative)

            memcpy(characters + m_heapNameLength, "_neg_", 5);

        else

            characters[m_heapNameLength] = '_';

        size_t accumulator = index;

        for (unsigned i = 0; i < numHexlets; ++i) {

            characters[stringLength - i - 1] = ("0123456789ABCDEF")[accumulator & 0xF];

            accumulator >>= 4;

        }

        field.initialize(&m_heapForAnyIndex, characters, signedIndex * m_elementSize);

        return;

    }

    RELEASE_ASSERT_NOT_REACHED();

}

NumberedAbstractHeap::NumberedAbstractHeap(AbstractHeap* heap, const char* heapName)

    : m_indexedHeap(heap, heapName, 1)

{

}

NumberedAbstractHeap::~NumberedAbstractHeap()

{

}

AbsoluteAbstractHeap::AbsoluteAbstractHeap(AbstractHeap* heap, const char* heapName)

    : m_indexedHeap(heap, heapName, 1)

{

}

AbsoluteAbstractHeap::~AbsoluteAbstractHeap()

{

}

} } // namespace JSC::FTL

#endif // ENABLE(FTL_JIT)

/*

 * Copyright (C) 2013 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#ifndef FTLAbstractHeap_h

#define FTLAbstractHeap_h

#include <wtf/Platform.h>

#if ENABLE(FTL_JIT)

#include "FTLAbbreviations.h"

#include <wtf/FastAllocBase.h>

#include <wtf/FixedArray.h>

#include <wtf/HashMap.h>

#include <wtf/Noncopyable.h>

#include <wtf/OwnPtr.h>

#include <wtf/Vector.h>

#include <wtf/text/CString.h>

namespace JSC { namespace FTL {

// The FTL JIT tries to aid LLVM's TBAA. The FTL's notion of how this

// happens is the AbstractHeap. AbstractHeaps are a simple type system

// with sub-typing.

class AbstractHeapRepository;

class AbstractHeap {

    WTF_MAKE_NONCOPYABLE(AbstractHeap); WTF_MAKE_FAST_ALLOCATED;

public:

    AbstractHeap()

        : m_parent(0)

        , m_heapName(0)

        , m_tbaaMetadata(0)

    {

    }

    AbstractHeap(AbstractHeap* parent, const char* heapName)

        : m_parent(parent)

        , m_heapName(heapName)

        , m_tbaaMetadata(0)

    {

    }

    bool isInitialized() const { return !!m_heapName; }

    void initialize(AbstractHeap* parent, const char* heapName)

    {

        m_parent = parent;

        m_heapName = heapName;

    }

    AbstractHeap* parent() const

    {

        ASSERT(isInitialized());

        return m_parent;

    }

    const char* heapName() const

    {

        ASSERT(isInitialized());

        return m_heapName;

    }

    LValue tbaaMetadata(const AbstractHeapRepository& repository) const

    {

        ASSERT(isInitialized());

        if (LIKELY(!!m_tbaaMetadata))

            return m_tbaaMetadata;

        return tbaaMetadataSlow(repository);

    }

    void decorateInstruction(LValue instruction, const AbstractHeapRepository&) const;

private:

    friend class AbstractHeapRepository;

    LValue tbaaMetadataSlow(const AbstractHeapRepository&) const;

    AbstractHeap* m_parent;

    const char* m_heapName;

    mutable LValue m_tbaaMetadata;

};

// Think of "AbstractField" as being an "AbstractHeapWithOffset". I would have named

// it the latter except that I don't like typing that much.

class AbstractField : public AbstractHeap {

public:

    AbstractField()

    {

    }

    AbstractField(AbstractHeap* parent, const char* heapName, ptrdiff_t offset)

        : AbstractHeap(parent, heapName)

        , m_offset(offset)

    {

    }

    void initialize(AbstractHeap* parent, const char* heapName, ptrdiff_t offset)

    {

        AbstractHeap::initialize(parent, heapName);

        m_offset = offset;

    }

    ptrdiff_t offset() const

    {

        ASSERT(isInitialized());

        return m_offset;

    }

private:

    ptrdiff_t m_offset;

};

class IndexedAbstractHeap {

public:

    IndexedAbstractHeap(AbstractHeap* parent, const char* heapName, size_t elementSize);

    ~IndexedAbstractHeap();

    const AbstractHeap& atAnyIndex() const { return m_heapForAnyIndex; }

    const AbstractField& at(ptrdiff_t index)

    {

        if (static_cast<size_t>(index) < m_smallIndices.size())

            return returnInitialized(m_smallIndices[index], index);

        return atSlow(index);

    }

    const AbstractField& operator[](ptrdiff_t index) { return at(index); }

private:

    const AbstractField& returnInitialized(AbstractField& field, ptrdiff_t index)

    {

        if (UNLIKELY(!field.isInitialized()))

            initialize(field, index);

        return field;

    }

    const AbstractField& atSlow(ptrdiff_t index);

    void initialize(AbstractField& field, ptrdiff_t index);

    AbstractHeap m_heapForAnyIndex;

    size_t m_heapNameLength;

    size_t m_elementSize;

    FixedArray<AbstractField, 16> m_smallIndices;

    struct MyHashTraits : WTF::GenericHashTraits<ptrdiff_t> {

        static void constructDeletedValue(ptrdiff_t& slot) { slot = 1; }

        static bool isDeletedValue(ptrdiff_t value) { return value == 1; }

    };

    typedef HashMap<ptrdiff_t, OwnPtr<AbstractField>, WTF::IntHash<ptrdiff_t>, MyHashTraits> MapType;

    OwnPtr<MapType> m_largeIndices;

    Vector<CString, 16> m_largeIndexNames;

};

// A numbered abstract heap is like an indexed abstract heap, except that you

// can't rely on there being a relationship between the number you use to

// retrieve the sub-heap, and the offset that this heap has. (In particular,

// the sub-heaps don't have indices.)

class NumberedAbstractHeap {

public:

    NumberedAbstractHeap(AbstractHeap* parent, const char* heapName);

    ~NumberedAbstractHeap();

    const AbstractHeap& atAnyNumber() const { return m_indexedHeap.atAnyIndex(); }

    const AbstractHeap& at(unsigned number) { return m_indexedHeap.at(number); }

    const AbstractHeap& operator[](unsigned number) { return at(number); }

private:

    // We use the fact that the indexed heap already has a superset of the

    // functionality we need.

    IndexedAbstractHeap m_indexedHeap;

};

class AbsoluteAbstractHeap {

public:

    AbsoluteAbstractHeap(AbstractHeap* parent, const char* heapName);

    ~AbsoluteAbstractHeap();

    const AbstractHeap& atAnyAddress() const { return m_indexedHeap.atAnyIndex(); }

    const AbstractHeap& at(void* address)

    {

        return m_indexedHeap.at(bitwise_cast<ptrdiff_t>(address));

    }

    const AbstractHeap& operator[](void* address) { return at(address); }

private:

    // The trick here is that the indexed heap is "indexed" by a pointer-width

    // integer. Pointers are themselves pointer-width integers. So we can reuse

    // all of the functionality.

    IndexedAbstractHeap m_indexedHeap;

};

} } // namespace JSC::FTL

#endif // ENABLE(FTL_JIT)

#endif // FTLAbstractHeap_h

/*

 * Copyright (C) 2013 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "FTLAbstractHeapRepository.h"

#if ENABLE(FTL_JIT)

#include "Operations.h"

namespace JSC { namespace FTL {

AbstractHeapRepository::AbstractHeapRepository()

    : root(0, "root")

#define ABSTRACT_HEAP_DECLARATION(name) , name(&root, #name)

    FOR_EACH_ABSTRACT_HEAP(ABSTRACT_HEAP_DECLARATION)

#undef ABSTRACT_HEAP_DECLARATION

#define ABSTRACT_FIELD_DECLARATION(name, offset) , name(&root, #name, offset)

    FOR_EACH_ABSTRACT_FIELD(ABSTRACT_FIELD_DECLARATION)

#undef ABSTRACT_FIELD_DECLARATION

#define INDEXED_ABSTRACT_HEAP_DECLARATION(name, size) , name(&root, #name, size)

    FOR_EACH_INDEXED_ABSTRACT_HEAP(INDEXED_ABSTRACT_HEAP_DECLARATION)

#undef INDEXED_ABSTRACT_HEAP_DECLARATION

#define NUMBERED_ABSTRACT_HEAP_DECLARATION(name) , name(&root, #name)

    FOR_EACH_NUMBERED_ABSTRACT_HEAP(NUMBERED_ABSTRACT_HEAP_DECLARATION)

#undef NUMBERED_ABSTRACT_HEAP_DECLARATION

#define ABSOLUTE_ABSTRACT_HEAP_DECLARATION(name) , name(&root, #name)

    FOR_EACH_ABSOLUTE_ABSTRACT_HEAP(ABSOLUTE_ABSTRACT_HEAP_DECLARATION)

#undef ABSOLUTE_ABSTRACT_HEAP_DECLARATION

    , m_tbaaKind(mdKindID("tbaa"))

{

    root.m_tbaaMetadata = mdNode(mdString(root.m_heapName));

    RELEASE_ASSERT(m_tbaaKind);

    RELEASE_ASSERT(root.m_tbaaMetadata);

}

AbstractHeapRepository::~AbstractHeapRepository()

{

}

} } // namespace JSC::FTL

#endif // ENABLE(FTL_JIT)

/*

 * Copyright (C) 2013 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#ifndef FTLAbstractHeapRepository_h

#define FTLAbstractHeapRepository_h

#include <wtf/Platform.h>

#if ENABLE(FTL_JIT)

#include "FTLAbstractHeap.h"

namespace JSC { namespace FTL {

#define FOR_EACH_ABSTRACT_HEAP(macro) \

    macro(typedArrayProperties) \

    macro(length)

#define FOR_EACH_ABSTRACT_FIELD(macro) \

    macro(JSCell_structure, JSCell::structureOffset()) \

    macro(JSObject_butterfly, JSObject::butterflyOffset()) \

    macro(Butterfly_publicLength, Butterfly::offsetOfPublicLength())

#define FOR_EACH_INDEXED_ABSTRACT_HEAP(macro) \

    macro(variables, sizeof(Register)) \

    macro(indexedInt32Properties, sizeof(EncodedJSValue)) \

    macro(indexedDoubleProperties, sizeof(double)) \

    macro(indexedContiguousProperties, sizeof(EncodedJSValue)) \

    macro(indexedArrayStorageProperties, sizeof(EncodedJSValue))

#define FOR_EACH_NUMBERED_ABSTRACT_HEAP(macro) \

    macro(properties)

#define FOR_EACH_ABSOLUTE_ABSTRACT_HEAP(macro) \

    macro(globalVariables)

// This class is meant to be cacheable between compilations, but it doesn't have to be.

// Doing so saves on creation of nodes. But clearing it will save memory.

class AbstractHeapRepository {

    WTF_MAKE_NONCOPYABLE(AbstractHeapRepository);

public:

    AbstractHeapRepository();

    ~AbstractHeapRepository();

    AbstractHeap root;

#define ABSTRACT_HEAP_DECLARATION(name) AbstractHeap name;

    FOR_EACH_ABSTRACT_HEAP(ABSTRACT_HEAP_DECLARATION)

#undef ABSTRACT_HEAP_DECLARATION

#define ABSTRACT_FIELD_DECLARATION(name, offset) AbstractField name;

    FOR_EACH_ABSTRACT_FIELD(ABSTRACT_FIELD_DECLARATION)

#undef ABSTRACT_FIELD_DECLARATION

#define INDEXED_ABSTRACT_HEAP_DECLARATION(name, size) IndexedAbstractHeap name;

    FOR_EACH_INDEXED_ABSTRACT_HEAP(INDEXED_ABSTRACT_HEAP_DECLARATION)

#undef INDEXED_ABSTRACT_HEAP_DECLARATION

#define NUMBERED_ABSTRACT_HEAP_DECLARATION(name) NumberedAbstractHeap name;

    FOR_EACH_NUMBERED_ABSTRACT_HEAP(NUMBERED_ABSTRACT_HEAP_DECLARATION)

#undef NUMBERED_ABSTRACT_HEAP_DECLARATION

#define ABSOLUTE_ABSTRACT_HEAP_DECLARATION(name) AbsoluteAbstractHeap name;

    FOR_EACH_ABSOLUTE_ABSTRACT_HEAP(ABSOLUTE_ABSTRACT_HEAP_DECLARATION)

#undef ABSOLUTE_ABSTRACT_HEAP_DECLARATION

private:

    friend class AbstractHeap;

    unsigned m_tbaaKind;

};

} } // namespace JSC::FTL

#endif // ENABLE(FTL_JIT)

#endif // FTLAbstractHeapRepository_h

#include "FTLAbstractHeapRepository.h"

    AbstractHeapRepository m_heaps;

#include "FTLAbstractHeapRepository.h"

#include "FTLTypedPointer.h"

// We say that a "typed pointer" is a pointer that carries TBAA meta-data (i.e. an

// AbstractHeap). These should usually not have further computation performed on them

// prior to access, though there are exceptions (like offsetting into the payload of

// a typed pointer to a JSValue).

//

        , m_module(0)

        , m_heaps(0)

        m_heaps = &heaps;

    AbstractHeapRepository* m_heaps;

/*

 * Copyright (C) 2013 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#ifndef FTLTypedPointer_h

#define FTLTypedPointer_h

#include <wtf/Platform.h>

#if ENABLE(FTL_JIT)

#include "FTLAbbreviations.h"

#include "FTLAbstractHeap.h"

namespace JSC { namespace FTL {

class TypedPointer {

public:

    TypedPointer()

        : m_heap(0)

        , m_value(0)

    {

    }

    TypedPointer(const AbstractHeap& heap, LValue value)

        : m_heap(&heap)

        , m_value(value)

    {

    }

    bool operator!() const

    {

        ASSERT(!m_heap == !m_value);

        return !m_heap;

    }

    const AbstractHeap& heap() const { return *m_heap; }

    LValue value() const { return m_value; }

private:

    const AbstractHeap* m_heap;

    LValue m_value;

};

} } // namespace JSC::FTL

#endif // ENABLE(FTL_JIT)

#endif // FTLTypedPointer_h

    v(bool, useFTLTBAA, true) \