DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (5b81998bb7ab)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=4 sw=4 et tw=99:
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#if !defined jsjaeger_imm_sync_h__ && defined JS_METHODJIT && defined JS_NUNBOX32
#define jsjaeger_imm_sync_h__

#include "methodjit/MachineRegs.h"
#include "methodjit/FrameEntry.h"
#include "CodeGenIncludes.h"

namespace js {
namespace mjit {

class FrameState;

/*
 * This is a structure nestled within the FrameState used for safely syncing
 * registers to memory during transitions from the fast path into a slow path
 * stub call. During this process, the frame itself is immutable, and we may
 * run out of registers needed to remat copies.
 *
 * This structure maintains a mapping of the tracker used to perform ad-hoc
 * register allocation.
 */
class ImmutableSync
{
    typedef JSC::MacroAssembler::RegisterID RegisterID;
    typedef JSC::MacroAssembler::Address Address;

    struct SyncEntry {
        /*
         * NB: clobbered and sync mean the same thing: the register associated
         * in the FrameEntry is no longer valid, and has been written back.
         *
         * They are separated for readability.
         */
        uint32_t generation;
        bool dataClobbered;
        bool typeClobbered;
        bool hasDataReg;
        bool hasTypeReg;
        bool learnedType;
        RegisterID dataReg;
        RegisterID typeReg;
        JSValueType type;

        void reset(uint32_t gen) {
            dataClobbered = false;
            typeClobbered = false;
            hasDataReg = false;
            hasTypeReg = false;
            learnedType = false;
            generation = gen;
        }
    };

  public:
    ImmutableSync();
    ~ImmutableSync();
    bool init(JSContext *cx, const FrameState &frame, uint32_t nentries);

    void reset(Assembler *masm, Registers avail, FrameEntry *top, FrameEntry *bottom);
    void sync(FrameEntry *fe);

  private:
    void syncCopy(FrameEntry *fe);
    void syncNormal(FrameEntry *fe);
    RegisterID ensureDataReg(FrameEntry *fe, SyncEntry &e);
    RegisterID ensureTypeReg(FrameEntry *fe, SyncEntry &e);

    RegisterID allocReg();
    void freeReg(RegisterID reg);

    /* To be called only by allocReg. */
    RegisterID doAllocReg();

    inline SyncEntry &entryFor(FrameEntry *fe);

    bool shouldSyncType(FrameEntry *fe, SyncEntry &e);
    bool shouldSyncData(FrameEntry *fe, SyncEntry &e);

  private:
    JSContext *cx;
    SyncEntry *entries;
    const FrameState *frame;
    uint32_t nentries;
    Registers avail;
    Assembler *masm;
    SyncEntry *regs[Assembler::TotalRegisters];
    FrameEntry *top;
    FrameEntry *bottom;
    uint32_t generation;
};

} /* namespace mjit */
} /* namespace js */

#endif /* jsjaeger_imm_sync_h__ */