The Tor Browser: js/src/jit/shared/CodeGenerator-shared.h@6474c204b198 (annotated)

js/src/jit/shared/CodeGenerator-shared.h@6474c204b198 (annotated)

js/src/jit/shared/CodeGenerator-shared.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 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/. */
 #ifndef jit_shared_CodeGenerator_shared_h
 #define jit_shared_CodeGenerator_shared_h
 #include "mozilla/Alignment.h"
 #include "jit/IonFrames.h"
 #include "jit/IonMacroAssembler.h"
 #include "jit/LIR.h"
 #include "jit/MIRGenerator.h"
 #include "jit/MIRGraph.h"
 #include "jit/Safepoints.h"
 #include "jit/Snapshots.h"
 #include "jit/VMFunctions.h"
 #include "vm/ForkJoin.h"
 namespace js {
 namespace jit {
 class OutOfLineCode;
 class CodeGenerator;
 class MacroAssembler;
 class IonCache;
 class OutOfLineAbortPar;
 class OutOfLinePropagateAbortPar;
 template <class ArgSeq, class StoreOutputTo>
 class OutOfLineCallVM;
 class OutOfLineTruncateSlow;
 struct PatchableBackedgeInfo
 {
     CodeOffsetJump backedge;
     Label *loopHeader;
     Label *interruptCheck;
     PatchableBackedgeInfo(CodeOffsetJump backedge, Label *loopHeader, Label *interruptCheck)
       : backedge(backedge), loopHeader(loopHeader), interruptCheck(interruptCheck)
     {}
 };
 struct ReciprocalMulConstants {
     int32_t multiplier;
     int32_t shiftAmount;
 };
 class CodeGeneratorShared : public LInstructionVisitor
 {
     js::Vector<OutOfLineCode *, 0, SystemAllocPolicy> outOfLineCode_;
     OutOfLineCode *oolIns;
     MacroAssembler &ensureMasm(MacroAssembler *masm);
     mozilla::Maybe<MacroAssembler> maybeMasm_;
   public:
     MacroAssembler &masm;
   protected:
     MIRGenerator *gen;
     LIRGraph &graph;
     LBlock *current;
     SnapshotWriter snapshots_;
     RecoverWriter recovers_;
     JitCode *deoptTable_;
 #ifdef DEBUG
     uint32_t pushedArgs_;
 #endif
     uint32_t lastOsiPointOffset_;
     SafepointWriter safepoints_;
     Label invalidate_;
     CodeOffsetLabel invalidateEpilogueData_;
     js::Vector<SafepointIndex, 0, SystemAllocPolicy> safepointIndices_;
     js::Vector<OsiIndex, 0, SystemAllocPolicy> osiIndices_;
     // Mapping from bailout table ID to an offset in the snapshot buffer.
     js::Vector<SnapshotOffset, 0, SystemAllocPolicy> bailouts_;
     // Allocated data space needed at runtime.
     js::Vector<uint8_t, 0, SystemAllocPolicy> runtimeData_;
     // Vector of information about generated polymorphic inline caches.
     js::Vector<uint32_t, 0, SystemAllocPolicy> cacheList_;
     // List of stack slots that have been pushed as arguments to an MCall.
     js::Vector<uint32_t, 0, SystemAllocPolicy> pushedArgumentSlots_;
     // Patchable backedges generated for loops.
     Vector<PatchableBackedgeInfo, 0, SystemAllocPolicy> patchableBackedges_;
 #ifdef JS_TRACE_LOGGING
     js::Vector<CodeOffsetLabel, 0, SystemAllocPolicy> patchableTraceLoggers_;
     js::Vector<CodeOffsetLabel, 0, SystemAllocPolicy> patchableTLScripts_;
 #endif
     // When profiling is enabled, this is the instrumentation manager which
     // maintains state of what script is currently being generated (for inline
     // scripts) and when instrumentation needs to be emitted or skipped.
     IonInstrumentation sps_;
   protected:
     // The offset of the first instruction of the OSR entry block from the
     // beginning of the code buffer.
     size_t osrEntryOffset_;
     TempAllocator &alloc() const {
         return graph.mir().alloc();
     }
     inline void setOsrEntryOffset(size_t offset) {
         JS_ASSERT(osrEntryOffset_ == 0);
         osrEntryOffset_ = offset;
     }
     inline size_t getOsrEntryOffset() const {
         return osrEntryOffset_;
     }
     // The offset of the first instruction of the body.
     // This skips the arguments type checks.
     size_t skipArgCheckEntryOffset_;
     inline void setSkipArgCheckEntryOffset(size_t offset) {
         JS_ASSERT(skipArgCheckEntryOffset_ == 0);
         skipArgCheckEntryOffset_ = offset;
     }
     inline size_t getSkipArgCheckEntryOffset() const {
         return skipArgCheckEntryOffset_;
     }
     typedef js::Vector<SafepointIndex, 8, SystemAllocPolicy> SafepointIndices;
     bool markArgumentSlots(LSafepoint *safepoint);
     void dropArguments(unsigned argc);
   protected:
     // The initial size of the frame in bytes. These are bytes beyond the
     // constant header present for every Ion frame, used for pre-determined
     // spills.
     int32_t frameDepth_;
     // Frame class this frame's size falls into (see IonFrame.h).
     FrameSizeClass frameClass_;
     // For arguments to the current function.
     inline int32_t ArgToStackOffset(int32_t slot) const {
         return masm.framePushed() +
                (gen->compilingAsmJS() ? NativeFrameSize : sizeof(IonJSFrameLayout)) +
                slot;
     }
     // For the callee of the current function.
     inline int32_t CalleeStackOffset() const {
         return masm.framePushed() + IonJSFrameLayout::offsetOfCalleeToken();
     }
     inline int32_t SlotToStackOffset(int32_t slot) const {
         JS_ASSERT(slot > 0 && slot <= int32_t(graph.localSlotCount()));
         int32_t offset = masm.framePushed() - slot;
         JS_ASSERT(offset >= 0);
         return offset;
     }
     inline int32_t StackOffsetToSlot(int32_t offset) const {
         // See: SlotToStackOffset. This is used to convert pushed arguments
         // to a slot index that safepoints can use.
         //
         // offset = framePushed - slot
         // offset + slot = framePushed
         // slot = framePushed - offset
         return masm.framePushed() - offset;
     }
     // For argument construction for calls. Argslots are Value-sized.
     inline int32_t StackOffsetOfPassedArg(int32_t slot) const {
         // A slot of 0 is permitted only to calculate %esp offset for calls.
         JS_ASSERT(slot >= 0 && slot <= int32_t(graph.argumentSlotCount()));
         int32_t offset = masm.framePushed() -
                        graph.paddedLocalSlotsSize() -
                        (slot * sizeof(Value));
         // Passed arguments go below A function's local stack storage.
         // When arguments are being pushed, there is nothing important on the stack.
         // Therefore, It is safe to push the arguments down arbitrarily.  Pushing
         // by sizeof(Value) is desirable since everything on the stack is a Value.
         // Note that paddedLocalSlotCount() aligns to at least a Value boundary
         // specifically to support this.
         JS_ASSERT(offset >= 0);
         JS_ASSERT(offset % sizeof(Value) == 0);
         return offset;
     }
     inline int32_t ToStackOffset(const LAllocation *a) const {
         if (a->isArgument())
             return ArgToStackOffset(a->toArgument()->index());
         return SlotToStackOffset(a->toStackSlot()->slot());
     }
     uint32_t frameSize() const {
         return frameClass_ == FrameSizeClass::None() ? frameDepth_ : frameClass_.frameSize();
     }
   protected:
     // Ensure the cache is an IonCache while expecting the size of the derived
     // class. We only need the cache list at GC time. Everyone else can just take
     // runtimeData offsets.
     size_t allocateCache(const IonCache &, size_t size) {
         size_t dataOffset = allocateData(size);
         masm.propagateOOM(cacheList_.append(dataOffset));
         return dataOffset;
     }
 #ifdef CHECK_OSIPOINT_REGISTERS
     void resetOsiPointRegs(LSafepoint *safepoint);
     bool shouldVerifyOsiPointRegs(LSafepoint *safepoint);
     void verifyOsiPointRegs(LSafepoint *safepoint);
 #endif
   public:
     // When appending to runtimeData_, the vector might realloc, leaving pointers
     // int the origianl vector stale and unusable. DataPtr acts like a pointer,
     // but allows safety in the face of potentially realloc'ing vector appends.
     friend class DataPtr;
     template <typename T>
     class DataPtr
     {
         CodeGeneratorShared *cg_;
         size_t index_;
         T *lookup() {
             return reinterpret_cast<T *>(&cg_->runtimeData_[index_]);
         }
       public:
         DataPtr(CodeGeneratorShared *cg, size_t index)
           : cg_(cg), index_(index) { }
         T * operator ->() {
             return lookup();
         }
         T * operator *() {
             return lookup();
         }
     };
   protected:
     size_t allocateData(size_t size) {
         JS_ASSERT(size % sizeof(void *) == 0);
         size_t dataOffset = runtimeData_.length();
         masm.propagateOOM(runtimeData_.appendN(0, size));
         return dataOffset;
     }
     template <typename T>
     inline size_t allocateCache(const T &cache) {
         size_t index = allocateCache(cache, sizeof(mozilla::AlignedStorage2<T>));
         if (masm.oom())
             return SIZE_MAX;
         // Use the copy constructor on the allocated space.
         JS_ASSERT(index == cacheList_.back());
         new (&runtimeData_[index]) T(cache);
         return index;
     }
   protected:
     // Encodes an LSnapshot into the compressed snapshot buffer, returning
     // false on failure.
     bool encode(LRecoverInfo *recover);
     bool encode(LSnapshot *snapshot);
     bool encodeAllocations(LSnapshot *snapshot, MResumePoint *resumePoint, uint32_t *startIndex);
     // Attempts to assign a BailoutId to a snapshot, if one isn't already set.
     // If the bailout table is full, this returns false, which is not a fatal
     // error (the code generator may use a slower bailout mechanism).
     bool assignBailoutId(LSnapshot *snapshot);
     // Encode all encountered safepoints in CG-order, and resolve |indices| for
     // safepoint offsets.
     void encodeSafepoints();
     // Mark the safepoint on |ins| as corresponding to the current assembler location.
     // The location should be just after a call.
     bool markSafepoint(LInstruction *ins);
     bool markSafepointAt(uint32_t offset, LInstruction *ins);
     // Mark the OSI point |ins| as corresponding to the current
     // assembler location inside the |osiIndices_|. Return the assembler
     // location for the OSI point return location within
     // |returnPointOffset|.
     bool markOsiPoint(LOsiPoint *ins, uint32_t *returnPointOffset);
     // Ensure that there is enough room between the last OSI point and the
     // current instruction, such that:
     //  (1) Invalidation will not overwrite the current instruction, and
     //  (2) Overwriting the current instruction will not overwrite
     //      an invalidation marker.
     void ensureOsiSpace();
     OutOfLineCode *oolTruncateDouble(const FloatRegister &src, const Register &dest);
     bool emitTruncateDouble(const FloatRegister &src, const Register &dest);
     bool emitTruncateFloat32(const FloatRegister &src, const Register &dest);
     void emitPreBarrier(Register base, const LAllocation *index, MIRType type);
     void emitPreBarrier(Address address, MIRType type);
     inline bool isNextBlock(LBlock *block) {
         return current->mir()->id() + 1 == block->mir()->id();
     }
   public:
     // Save and restore all volatile registers to/from the stack, excluding the
     // specified register(s), before a function call made using callWithABI and
     // after storing the function call's return value to an output register.
     // (The only registers that don't need to be saved/restored are 1) the
     // temporary register used to store the return value of the function call,
     // if there is one [otherwise that stored value would be overwritten]; and
     // 2) temporary registers whose values aren't needed in the rest of the LIR
     // instruction [this is purely an optimization].  All other volatiles must
     // be saved and restored in case future LIR instructions need those values.)
     void saveVolatile(Register output) {
         RegisterSet regs = RegisterSet::Volatile();
         regs.takeUnchecked(output);
         masm.PushRegsInMask(regs);
     }
     void restoreVolatile(Register output) {
         RegisterSet regs = RegisterSet::Volatile();
         regs.takeUnchecked(output);
         masm.PopRegsInMask(regs);
     }
     void saveVolatile(FloatRegister output) {
         RegisterSet regs = RegisterSet::Volatile();
         regs.takeUnchecked(output);
         masm.PushRegsInMask(regs);
     }
     void restoreVolatile(FloatRegister output) {
         RegisterSet regs = RegisterSet::Volatile();
         regs.takeUnchecked(output);
         masm.PopRegsInMask(regs);
     }
     void saveVolatile(RegisterSet temps) {
         masm.PushRegsInMask(RegisterSet::VolatileNot(temps));
     }
     void restoreVolatile(RegisterSet temps) {
         masm.PopRegsInMask(RegisterSet::VolatileNot(temps));
     }
     void saveVolatile() {
         masm.PushRegsInMask(RegisterSet::Volatile());
     }
     void restoreVolatile() {
         masm.PopRegsInMask(RegisterSet::Volatile());
     }
     // These functions have to be called before and after any callVM and before
     // any modifications of the stack.  Modification of the stack made after
     // these calls should update the framePushed variable, needed by the exit
     // frame produced by callVM.
     inline void saveLive(LInstruction *ins);
     inline void restoreLive(LInstruction *ins);
     inline void restoreLiveIgnore(LInstruction *ins, RegisterSet reg);
     // Save/restore all registers that are both live and volatile.
     inline void saveLiveVolatile(LInstruction *ins);
     inline void restoreLiveVolatile(LInstruction *ins);
     template <typename T>
     void pushArg(const T &t) {
         masm.Push(t);
 #ifdef DEBUG
         pushedArgs_++;
 #endif
     }
     void storeResultTo(const Register &reg) {
         masm.storeCallResult(reg);
     }
     void storeFloatResultTo(const FloatRegister &reg) {
         masm.storeCallFloatResult(reg);
     }
     template <typename T>
     void storeResultValueTo(const T &t) {
         masm.storeCallResultValue(t);
     }
     bool callVM(const VMFunction &f, LInstruction *ins, const Register *dynStack = nullptr);
     template <class ArgSeq, class StoreOutputTo>
     inline OutOfLineCode *oolCallVM(const VMFunction &fun, LInstruction *ins, const ArgSeq &args,
                                     const StoreOutputTo &out);
     bool callVM(const VMFunctionsModal &f, LInstruction *ins, const Register *dynStack = nullptr) {
         return callVM(f[gen->info().executionMode()], ins, dynStack);
     }
     template <class ArgSeq, class StoreOutputTo>
     inline OutOfLineCode *oolCallVM(const VMFunctionsModal &f, LInstruction *ins,
                                     const ArgSeq &args, const StoreOutputTo &out)
     {
         return oolCallVM(f[gen->info().executionMode()], ins, args, out);
     }
     bool addCache(LInstruction *lir, size_t cacheIndex);
     size_t addCacheLocations(const CacheLocationList &locs, size_t *numLocs);
     ReciprocalMulConstants computeDivisionConstants(int d);
   protected:
     bool addOutOfLineCode(OutOfLineCode *code);
     bool hasOutOfLineCode() { return !outOfLineCode_.empty(); }
     bool generateOutOfLineCode();
     Label *labelForBackedgeWithImplicitCheck(MBasicBlock *mir);
     // Generate a jump to the start of the specified block, adding information
     // if this is a loop backedge. Use this in place of jumping directly to
     // mir->lir()->label(), or use getJumpLabelForBranch() if a label to use
     // directly is needed.
     void jumpToBlock(MBasicBlock *mir);
     void jumpToBlock(MBasicBlock *mir, Assembler::Condition cond);
   private:
     void generateInvalidateEpilogue();
   public:
     CodeGeneratorShared(MIRGenerator *gen, LIRGraph *graph, MacroAssembler *masm);
   public:
     template <class ArgSeq, class StoreOutputTo>
     bool visitOutOfLineCallVM(OutOfLineCallVM<ArgSeq, StoreOutputTo> *ool);
     bool visitOutOfLineTruncateSlow(OutOfLineTruncateSlow *ool);
     bool omitOverRecursedCheck() const;
   public:
     bool callTraceLIR(uint32_t blockIndex, LInstruction *lir, const char *bailoutName = nullptr);
     // Parallel aborts:
     //
     //    Parallel aborts work somewhat differently from sequential
     //    bailouts.  When an abort occurs, we first invoke
     //    ReportAbortPar() and then we return JS_ION_ERROR.  Each
     //    call on the stack will check for this error return and
     //    propagate it upwards until the C++ code that invoked the ion
     //    code is reached.
     //
     //    The snapshot that is provided to `oolAbortPar` is currently
     //    only used for error reporting, so that we can provide feedback
     //    to the user about which instruction aborted and (perhaps) why.
     OutOfLineAbortPar *oolAbortPar(ParallelBailoutCause cause, MBasicBlock *basicBlock,
                                    jsbytecode *bytecode);
     OutOfLineAbortPar *oolAbortPar(ParallelBailoutCause cause, LInstruction *lir);
     OutOfLinePropagateAbortPar *oolPropagateAbortPar(LInstruction *lir);
     virtual bool visitOutOfLineAbortPar(OutOfLineAbortPar *ool) = 0;
     virtual bool visitOutOfLinePropagateAbortPar(OutOfLinePropagateAbortPar *ool) = 0;
 #ifdef JS_TRACE_LOGGING
   protected:
     bool emitTracelogScript(bool isStart);
     bool emitTracelogTree(bool isStart, uint32_t textId);
   public:
     bool emitTracelogScriptStart() {
         return emitTracelogScript(/* isStart =*/ true);
     }
     bool emitTracelogScriptStop() {
         return emitTracelogScript(/* isStart =*/ false);
     }
     bool emitTracelogStartEvent(uint32_t textId) {
         return emitTracelogTree(/* isStart =*/ true, textId);
     }
     bool emitTracelogStopEvent(uint32_t textId) {
         return emitTracelogTree(/* isStart =*/ false, textId);
     }
 #endif
 };
 // An out-of-line path is generated at the end of the function.
 class OutOfLineCode : public TempObject
 {
     Label entry_;
     Label rejoin_;
     uint32_t framePushed_;
     jsbytecode *pc_;
     JSScript *script_;
   public:
     OutOfLineCode()
       : framePushed_(0),
         pc_(nullptr),
         script_(nullptr)
     { }
     virtual bool generate(CodeGeneratorShared *codegen) = 0;
     Label *entry() {
         return &entry_;
     }
     virtual void bind(MacroAssembler *masm) {
         masm->bind(entry());
     }
     Label *rejoin() {
         return &rejoin_;
     }
     void setFramePushed(uint32_t framePushed) {
         framePushed_ = framePushed;
     }
     uint32_t framePushed() const {
         return framePushed_;
     }
     void setSource(JSScript *script, jsbytecode *pc) {
         script_ = script;
         pc_ = pc;
     }
     jsbytecode *pc() {
         return pc_;
     }
     JSScript *script() {
         return script_;
     }
 };
 // For OOL paths that want a specific-typed code generator.
 template <typename T>
 class OutOfLineCodeBase : public OutOfLineCode
 {
   public:
     virtual bool generate(CodeGeneratorShared *codegen) {
         return accept(static_cast<T *>(codegen));
     }
   public:
     virtual bool accept(T *codegen) = 0;
 };
 // ArgSeq store arguments for OutOfLineCallVM.
 //
 // OutOfLineCallVM are created with "oolCallVM" function. The third argument of
 // this function is an instance of a class which provides a "generate" function
 // to call the "pushArg" needed by the VMFunction call.  The list of argument
 // can be created by using the ArgList function which create an empty list of
 // arguments.  Arguments are added to this list by using the comma operator.
 // The type of the argument list is returned by the comma operator, and due to
 // templates arguments, it is quite painful to write by hand.  It is recommended
 // to use it directly as argument of a template function which would get its
 // arguments infered by the compiler (such as oolCallVM).  The list of arguments
 // must be written in the same order as if you were calling the function in C++.
 //
 // Example:
 //   (ArgList(), ToRegister(lir->lhs()), ToRegister(lir->rhs()))
 template <class SeqType, typename LastType>
 class ArgSeq : public SeqType
 {
   private:
     typedef ArgSeq<SeqType, LastType> ThisType;
     LastType last_;
   public:
     ArgSeq(const SeqType &seq, const LastType &last)
       : SeqType(seq),
         last_(last)
     { }
     template <typename NextType>
     inline ArgSeq<ThisType, NextType>
     operator, (const NextType &last) const {
         return ArgSeq<ThisType, NextType>(*this, last);
     }
     inline void generate(CodeGeneratorShared *codegen) const {
         codegen->pushArg(last_);
         this->SeqType::generate(codegen);
     }
 };
 // Mark the end of an argument list.
 template <>
 class ArgSeq<void, void>
 {
   private:
     typedef ArgSeq<void, void> ThisType;
   public:
     ArgSeq() { }
     ArgSeq(const ThisType &) { }
     template <typename NextType>
     inline ArgSeq<ThisType, NextType>
     operator, (const NextType &last) const {
         return ArgSeq<ThisType, NextType>(*this, last);
     }
     inline void generate(CodeGeneratorShared *codegen) const {
     }
 };
 inline ArgSeq<void, void>
 ArgList()
 {
     return ArgSeq<void, void>();
 }
 // Store wrappers, to generate the right move of data after the VM call.
 struct StoreNothing
 {
     inline void generate(CodeGeneratorShared *codegen) const {
     }
     inline RegisterSet clobbered() const {
         return RegisterSet(); // No register gets clobbered
     }
 };
 class StoreRegisterTo
 {
   private:
     Register out_;
   public:
     StoreRegisterTo(const Register &out)
       : out_(out)
     { }
     inline void generate(CodeGeneratorShared *codegen) const {
         codegen->storeResultTo(out_);
     }
     inline RegisterSet clobbered() const {
         RegisterSet set = RegisterSet();
         set.add(out_);
         return set;
     }
 };
 class StoreFloatRegisterTo
 {
   private:
     FloatRegister out_;
   public:
     StoreFloatRegisterTo(const FloatRegister &out)
       : out_(out)
     { }
     inline void generate(CodeGeneratorShared *codegen) const {
         codegen->storeFloatResultTo(out_);
     }
     inline RegisterSet clobbered() const {
         RegisterSet set = RegisterSet();
         set.add(out_);
         return set;
     }
 };
 template <typename Output>
 class StoreValueTo_
 {
   private:
     Output out_;
   public:
     StoreValueTo_(const Output &out)
       : out_(out)
     { }
     inline void generate(CodeGeneratorShared *codegen) const {
         codegen->storeResultValueTo(out_);
     }
     inline RegisterSet clobbered() const {
         RegisterSet set = RegisterSet();
         set.add(out_);
         return set;
     }
 };
 template <typename Output>
 StoreValueTo_<Output> StoreValueTo(const Output &out)
 {
     return StoreValueTo_<Output>(out);
 }
 template <class ArgSeq, class StoreOutputTo>
 class OutOfLineCallVM : public OutOfLineCodeBase<CodeGeneratorShared>
 {
   private:
     LInstruction *lir_;
     const VMFunction &fun_;
     ArgSeq args_;
     StoreOutputTo out_;
   public:
     OutOfLineCallVM(LInstruction *lir, const VMFunction &fun, const ArgSeq &args,
                     const StoreOutputTo &out)
       : lir_(lir),
         fun_(fun),
         args_(args),
         out_(out)
     { }
     bool accept(CodeGeneratorShared *codegen) {
         return codegen->visitOutOfLineCallVM(this);
     }
     LInstruction *lir() const { return lir_; }
     const VMFunction &function() const { return fun_; }
     const ArgSeq &args() const { return args_; }
     const StoreOutputTo &out() const { return out_; }
 };
 template <class ArgSeq, class StoreOutputTo>
 inline OutOfLineCode *
 CodeGeneratorShared::oolCallVM(const VMFunction &fun, LInstruction *lir, const ArgSeq &args,
                                const StoreOutputTo &out)
 {
     OutOfLineCode *ool = new(alloc()) OutOfLineCallVM<ArgSeq, StoreOutputTo>(lir, fun, args, out);
     if (!addOutOfLineCode(ool))
         return nullptr;
     return ool;
 }
 template <class ArgSeq, class StoreOutputTo>
 bool
 CodeGeneratorShared::visitOutOfLineCallVM(OutOfLineCallVM<ArgSeq, StoreOutputTo> *ool)
 {
     LInstruction *lir = ool->lir();
     saveLive(lir);
     ool->args().generate(this);
     if (!callVM(ool->function(), lir))
         return false;
     ool->out().generate(this);
     restoreLiveIgnore(lir, ool->out().clobbered());
     masm.jump(ool->rejoin());
     return true;
 }
 // Initiate a parallel abort.  The snapshot is used to record the
 // cause.
 class OutOfLineAbortPar : public OutOfLineCode
 {
   private:
     ParallelBailoutCause cause_;
     MBasicBlock *basicBlock_;
     jsbytecode *bytecode_;
   public:
     OutOfLineAbortPar(ParallelBailoutCause cause, MBasicBlock *basicBlock, jsbytecode *bytecode)
       : cause_(cause),
         basicBlock_(basicBlock),
         bytecode_(bytecode)
     { }
     ParallelBailoutCause cause() {
         return cause_;
     }
     MBasicBlock *basicBlock() {
         return basicBlock_;
     }
     jsbytecode *bytecode() {
         return bytecode_;
     }
     bool generate(CodeGeneratorShared *codegen);
 };
 // Used when some callee has aborted.
 class OutOfLinePropagateAbortPar : public OutOfLineCode
 {
   private:
     LInstruction *lir_;
   public:
     OutOfLinePropagateAbortPar(LInstruction *lir)
       : lir_(lir)
     { }
     LInstruction *lir() { return lir_; }
     bool generate(CodeGeneratorShared *codegen);
 };
 extern const VMFunction InterruptCheckInfo;
 } // namespace jit
 } // namespace js
 #endif /* jit_shared_CodeGenerator_shared_h */

The Tor Browser / annotate

js/src/jit/shared/CodeGenerator-shared.h@6474c204b198 (annotated)

js/src/jit/shared/CodeGenerator-shared.h