mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1042833 - Add 'none' architecture used in --disable-ion builds, r=jandem.

This commit is contained in:
Brian Hackett 2014-07-28 11:37:48 -08:00
Родитель 89ad921463
Коммит 8081742abe
34 изменённых файлов: 1099 добавлений и 120 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

11
js/src/configure.in
Просмотреть файл

@ -2024,9 +2024,7 @@ AC_SUBST(ENABLE_METHODJIT_SPEW)
AC_SUBST(ENABLE_ION)
if test "$ENABLE_ION"; then
AC_DEFINE(JS_ION)
fi
AC_DEFINE(JS_ION)
if test -n "$COMPILE_ENVIRONMENT"; then
MOZ_COMPILER_OPTS
@ -3167,7 +3165,11 @@ MOZ_ARG_ENABLE_BOOL(arm-simulator,
[ --enable-arm-simulator Enable ARM simulator for JIT code],
JS_ARM_SIMULATOR=1,
JS_ARM_SIMULATOR= )
if test -n "$JS_ARM_SIMULATOR"; then
if test -z "$ENABLE_ION"; then
AC_DEFINE(JS_CODEGEN_NONE)
JS_CODEGEN_NONE=1
elif test -n "$JS_ARM_SIMULATOR"; then
if test "$CPU_ARCH" != "x86"; then
AC_MSG_ERROR([The ARM simulator only works on x86.])
fi
@ -3189,6 +3191,7 @@ AC_SUBST(JS_ARM_SIMULATOR)
AC_SUBST(JS_CODEGEN_ARM)
AC_SUBST(JS_CODEGEN_X86)
AC_SUBST(JS_CODEGEN_X64)
AC_SUBST(JS_CODEGEN_NONE)
dnl ========================================================
dnl jprof

12
js/src/irregexp/RegExpEngine.cpp
Просмотреть файл

@ -1566,6 +1566,16 @@ SampleChars(FrequencyCollator *collator, const CharT *chars, size_t length)
}
}
static bool
IsNativeRegExpEnabled(JSContext *cx)
{
#ifdef JS_CODEGEN_NONE
return false;
#else
return cx->runtime()->options().nativeRegExp();
#endif
}
RegExpCode
irregexp::CompilePattern(JSContext *cx, RegExpShared *shared, RegExpCompileData *data,
HandleLinearString sample, bool is_global, bool ignore_case,
@ -1647,7 +1657,7 @@ irregexp::CompilePattern(JSContext *cx, RegExpShared *shared, RegExpCompileData
Maybe<InterpretedRegExpMacroAssembler> interpreted_assembler;
RegExpMacroAssembler *assembler;
if (cx->runtime()->options().nativeRegExp()) {
if (IsNativeRegExpEnabled(cx)) {
NativeRegExpMacroAssembler::Mode mode =
is_ascii ? NativeRegExpMacroAssembler::ASCII
: NativeRegExpMacroAssembler::JSCHAR;

12
js/src/jit/AsmJS.cpp
Просмотреть файл

@ -6251,7 +6251,7 @@ GenerateFFIIonExit(ModuleCompiler &m, const ModuleCompiler::ExitDescriptor &exit
#elif defined(JS_CODEGEN_X86)
m.masm().append(AsmJSGlobalAccess(masm.movlWithPatch(Imm32(0), callee), globalDataOffset));
#else
masm.lea(Operand(GlobalReg, globalDataOffset), callee);
masm.computeEffectiveAddress(Address(GlobalReg, globalDataOffset), callee);
#endif
// 2.2. Get callee
@ -6683,6 +6683,8 @@ GenerateAsyncInterruptExit(ModuleCompiler &m, Label *throwLabel)
masm.finishDataTransfer();
masm.ret();
#elif defined (JS_CODEGEN_NONE)
MOZ_CRASH();
#else
# error "Unknown architecture!"
#endif
@ -6864,6 +6866,10 @@ Warn(AsmJSParser &parser, int errorNumber, const char *str)
static bool
EstablishPreconditions(ExclusiveContext *cx, AsmJSParser &parser)
{
#ifdef JS_CODEGEN_NONE
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by lack of a JIT compiler");
#endif
if (!cx->jitSupportsFloatingPoint())
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by lack of floating point support");
@ -6933,10 +6939,14 @@ js::IsAsmJSCompilationAvailable(JSContext *cx, unsigned argc, Value *vp)
CallArgs args = CallArgsFromVp(argc, vp);
// See EstablishPreconditions.
#ifdef JS_CODEGEN_NONE
bool available = false;
#else
bool available = cx->jitSupportsFloatingPoint() &&
cx->gcSystemPageSize() == AsmJSPageSize &&
!cx->compartment()->debugMode() &&
cx->runtime()->options().asmJS();
#endif
args.rval().set(BooleanValue(available));
return true;

6
js/src/jit/AsmJSFrameIterator.cpp
Просмотреть файл

@ -109,6 +109,12 @@ static const unsigned StoredFP = 12;
static const unsigned PushedRetAddr = 4;
static const unsigned PushedFP = 16;
static const unsigned StoredFP = 20;
#elif defined(JS_CODEGEN_NONE)
static const unsigned PushedRetAddr = 0;
static const unsigned PushedFP = 1;
static const unsigned StoredFP = 1;
#else
# error "Unknown architecture!"
#endif
static void

7
js/src/jit/AsmJSModule.cpp
Просмотреть файл

@ -1558,6 +1558,9 @@ AsmJSModule::setProfilingEnabled(bool enabled, JSContext *cx)
BOffImm calleeOffset;
callerInsn->as<InstBLImm>()->extractImm(&calleeOffset);
void *callee = calleeOffset.getDest(callerInsn);
#elif defined(JS_CODEGEN_NONE)
MOZ_CRASH();
void *callee = nullptr;
#else
# error "Missing architecture"
#endif
@ -1576,6 +1579,8 @@ AsmJSModule::setProfilingEnabled(bool enabled, JSContext *cx)
JSC::X86Assembler::setRel32(callerRetAddr, newCallee);
#elif defined(JS_CODEGEN_ARM)
new (caller) InstBLImm(BOffImm(newCallee - caller), Assembler::Always);
#elif defined(JS_CODEGEN_NONE)
MOZ_CRASH();
#else
# error "Missing architecture"
#endif
@ -1633,6 +1638,8 @@ AsmJSModule::setProfilingEnabled(bool enabled, JSContext *cx)
JS_ASSERT(reinterpret_cast<Instruction*>(jump)->is<InstBImm>());
new (jump) InstNOP();
}
#elif defined(JS_CODEGEN_NONE)
MOZ_CRASH();
#else
# error "Missing architecture"
#endif

7
js/src/jit/AsmJSSignalHandlers.cpp
Просмотреть файл

@ -515,6 +515,8 @@ ContextToPC(x86_thread_state_t &state)
# if defined(JS_CODEGEN_X64)
JS_STATIC_ASSERT(sizeof(state.uts.ts64.__rip) == sizeof(void*));
return reinterpret_cast<uint8_t**>(&state.uts.ts64.__rip);
# elif defined(JS_CODEGEN_NONE)
MOZ_CRASH();
# else
JS_STATIC_ASSERT(sizeof(state.uts.ts32.__eip) == sizeof(void*));
return reinterpret_cast<uint8_t**>(&state.uts.ts32.__eip);
@ -973,6 +975,11 @@ static bool sHandlersInstalled = false;
bool
js::EnsureAsmJSSignalHandlersInstalled(JSRuntime *rt)
{
#ifdef JS_CODEGEN_NONE
// Don't install signal handlers in builds with the JIT disabled.
return false;
#endif
if (IsSignalHandlingBroken())
return false;

2
js/src/jit/BaselineBailouts.cpp
Просмотреть файл

@ -371,6 +371,8 @@ struct BaselineStackBuilder
size_t extraOffset = IonRectifierFrameLayout::Size() + priorFrame->prevFrameLocalSize() +
IonBaselineStubFrameLayout::reverseOffsetOfSavedFramePtr();
return virtualPointerAtStackOffset(priorOffset + extraOffset);
#elif defined(JS_CODEGEN_NONE)
MOZ_CRASH();
#else
# error "Bad architecture!"
#endif

2
js/src/jit/BaselineCompiler.h
Просмотреть файл

@ -18,6 +18,8 @@
# include "jit/arm/BaselineCompiler-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/BaselineCompiler-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/BaselineCompiler-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/BaselineHelpers.h
Просмотреть файл

@ -17,6 +17,8 @@
# include "jit/arm/BaselineHelpers-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/BaselineHelpers-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/BaselineHelpers-none.h"
#else
# error "Unknown architecture!"
#endif

4
js/src/jit/BaselineJIT.h
Просмотреть файл

@ -345,7 +345,11 @@ struct BaselineScript
inline bool
IsBaselineEnabled(JSContext *cx)
{
#ifdef JS_CODEGEN_NONE
return false;
#else
return cx->runtime()->options().baseline();
#endif
}
MethodStatus

2
js/src/jit/BaselineRegisters.h
Просмотреть файл

@ -17,6 +17,8 @@
# include "jit/arm/BaselineRegisters-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/BaselineRegisters-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/BaselineRegisters-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/CodeGenerator.h
Просмотреть файл

@ -20,6 +20,8 @@
# include "jit/arm/CodeGenerator-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/CodeGenerator-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/CodeGenerator-none.h"
#else
#error "Unknown architecture!"
#endif

4
js/src/jit/Ion.h
Просмотреть файл

@ -159,9 +159,13 @@ void StopAllOffThreadCompilations(JSCompartment *comp);
static inline bool
IsIonEnabled(JSContext *cx)
{
#ifdef JS_CODEGEN_NONE
return false;
#else
return cx->runtime()->options().ion() &&
cx->runtime()->options().baseline() &&
cx->runtime()->jitSupportsFloatingPoint;
#endif
}
inline bool

2
js/src/jit/IonMacroAssembler.h
Просмотреть файл

@ -19,6 +19,8 @@
# include "jit/arm/MacroAssembler-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/MacroAssembler-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/MacroAssembler-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/LIR.h
Просмотреть файл

@ -1679,6 +1679,8 @@ LAllocation::toRegister() const
# include "jit/arm/LIR-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/LIR-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/LIR-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/LOpcodes.h
Просмотреть файл

@ -311,6 +311,8 @@
# include "jit/arm/LOpcodes-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/LOpcodes-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/LOpcodes-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/Lowering.h
Просмотреть файл

@ -19,6 +19,8 @@
# include "jit/arm/Lowering-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/Lowering-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/Lowering-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/MoveEmitter.h
Просмотреть файл

@ -13,6 +13,8 @@
# include "jit/arm/MoveEmitter-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/MoveEmitter-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/MoveEmitter-none.h"
#else
# error "Unknown architecture!"
#endif

2
js/src/jit/Registers.h
Просмотреть файл

@ -18,6 +18,8 @@
# include "jit/arm/Architecture-arm.h"
#elif defined(JS_CODEGEN_MIPS)
# include "jit/mips/Architecture-mips.h"
#elif defined(JS_CODEGEN_NONE)
# include "jit/none/Architecture-none.h"
#else
# error "Unknown architecture!"
#endif

112
js/src/jit/none/Architecture-none.h Normal file
Просмотреть файл

@ -0,0 +1,112 @@
/* -*- 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_none_Architecture_none_h
#define jit_none_Architecture_none_h
#include "assembler/assembler/MacroAssembler.h"
namespace js {
namespace jit {
class Registers
{
public:
typedef uint8_t Code;
typedef uint8_t SetType;
static uint32_t SetSize(SetType) { MOZ_CRASH(); }
static uint32_t FirstBit(SetType) { MOZ_CRASH(); }
static uint32_t LastBit(SetType) { MOZ_CRASH(); }
static const char *GetName(Code) { MOZ_CRASH(); }
static Code FromName(const char *) { MOZ_CRASH(); }
static const Code StackPointer = 0;
static const Code Invalid = 0;
static const uint32_t Total = 1;
static const uint32_t TotalPhys = 0;
static const uint32_t Allocatable = 0;
static const uint32_t AllMask = 0;
static const uint32_t ArgRegMask = 0;
static const uint32_t VolatileMask = 0;
static const uint32_t NonVolatileMask = 0;
static const uint32_t NonAllocatableMask = 0;
static const uint32_t AllocatableMask = 0;
static const uint32_t TempMask = 0;
static const uint32_t JSCallMask = 0;
static const uint32_t CallMask = 0;
};
typedef uint8_t PackedRegisterMask;
class FloatRegisters
{
public:
typedef uint8_t Code;
typedef uint32_t SetType;
static const char *GetName(Code) { MOZ_CRASH(); }
static Code FromName(const char *) { MOZ_CRASH(); }
static const Code Invalid = 0;
static const uint32_t Total = 0;
static const uint32_t TotalPhys = 0;
static const uint32_t Allocatable = 0;
static const uint32_t AllMask = 0;
static const uint32_t AllDoubleMask = 0;
static const uint32_t VolatileMask = 0;
static const uint32_t NonVolatileMask = 0;
static const uint32_t NonAllocatableMask = 0;
static const uint32_t AllocatableMask = 0;
};
template <typename T>
class TypedRegisterSet;
struct FloatRegister
{
typedef FloatRegisters Codes;
typedef Codes::Code Code;
typedef Codes::SetType SetType;
Code _;
static uint32_t FirstBit(SetType) { MOZ_CRASH(); }
static uint32_t LastBit(SetType) { MOZ_CRASH(); }
static FloatRegister FromCode(uint32_t) { MOZ_CRASH(); }
Code code() const { MOZ_CRASH(); }
const char *name() const { MOZ_CRASH(); }
bool volatile_() const { MOZ_CRASH(); }
bool operator != (FloatRegister) const { MOZ_CRASH(); }
bool operator == (FloatRegister) const { MOZ_CRASH(); }
bool aliases(FloatRegister) const { MOZ_CRASH(); }
uint32_t numAliased() const { MOZ_CRASH(); }
void aliased(uint32_t, FloatRegister *) { MOZ_CRASH(); }
bool equiv(FloatRegister) const { MOZ_CRASH(); }
uint32_t size() const { MOZ_CRASH(); }
uint32_t numAlignedAliased() const { MOZ_CRASH(); }
void alignedAliased(uint32_t, FloatRegister *) { MOZ_CRASH(); }
template <typename T> static T ReduceSetForPush(T) { MOZ_CRASH(); }
uint32_t getRegisterDumpOffsetInBytes() { MOZ_CRASH(); }
// This is used in static initializers, so produce a bogus value instead of crashing.
static uint32_t GetPushSizeInBytes(const TypedRegisterSet<FloatRegister> &) { return 0; }
};
inline bool hasUnaliasedDouble() { MOZ_CRASH(); }
inline bool hasMultiAlias() { MOZ_CRASH(); }
static const uint32_t ShadowStackSpace = 0;
#ifdef JS_NUNBOX32
static const int32_t NUNBOX32_TYPE_OFFSET = 4;
static const int32_t NUNBOX32_PAYLOAD_OFFSET = 0;
#endif
} // namespace jit
} // namespace js
#endif /* jit_none_Architecture_none_h */

30
js/src/jit/none/BaselineCompiler-none.h Normal file
Просмотреть файл

@ -0,0 +1,30 @@
/* -*- 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_none_BaselineCompiler_none_h
#define jit_none_BaselineCompiler_none_h
#include "jit/shared/BaselineCompiler-shared.h"
namespace js {
namespace jit {
class BaselineCompilerNone : public BaselineCompilerShared
{
protected:
BaselineCompilerNone(JSContext *cx, TempAllocator &alloc, JSScript *script)
: BaselineCompilerShared(cx, alloc, script)
{
MOZ_CRASH();
}
};
typedef BaselineCompilerNone BaselineCompilerSpecific;
} // namespace jit
} // namespace js
#endif /* jit_none_BaselineCompiler_none_h */

38
js/src/jit/none/BaselineHelpers-none.h Normal file
Просмотреть файл

@ -0,0 +1,38 @@
/* -*- 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_none_BaselineHelpers_none_h
#define jit_none_BaselineHelpers_none_h
namespace js {
namespace jit {
static const size_t ICStackValueOffset = 0;
static const uint32_t STUB_FRAME_SIZE = 0;
static const uint32_t STUB_FRAME_SAVED_STUB_OFFSET = 0;
inline void EmitRestoreTailCallReg(MacroAssembler &) { MOZ_CRASH(); }
inline void EmitRepushTailCallReg(MacroAssembler &) { MOZ_CRASH(); }
inline void EmitCallIC(CodeOffsetLabel *, MacroAssembler &) { MOZ_CRASH(); }
inline void EmitEnterTypeMonitorIC(MacroAssembler &, size_t v = 0) { MOZ_CRASH(); }
inline void EmitReturnFromIC(MacroAssembler &) { MOZ_CRASH(); }
inline void EmitChangeICReturnAddress(MacroAssembler &, Register) { MOZ_CRASH(); }
inline void EmitTailCallVM(JitCode *, MacroAssembler &, uint32_t) { MOZ_CRASH(); }
inline void EmitCreateStubFrameDescriptor(MacroAssembler &, Register) { MOZ_CRASH(); }
inline void EmitCallVM(JitCode *, MacroAssembler &) { MOZ_CRASH(); }
inline void EmitEnterStubFrame(MacroAssembler &, Register) { MOZ_CRASH(); }
inline void EmitLeaveStubFrame(MacroAssembler &, bool v = false) { MOZ_CRASH(); }
inline void EmitStowICValues(MacroAssembler &, int) { MOZ_CRASH(); }
inline void EmitUnstowICValues(MacroAssembler &, int, bool v = false) { MOZ_CRASH(); }
inline void EmitCallTypeUpdateIC(MacroAssembler &, JitCode *, uint32_t) { MOZ_CRASH(); }
inline void EmitStubGuardFailure(MacroAssembler &) { MOZ_CRASH(); }
template <typename T> inline void EmitPreBarrier(MacroAssembler &, T, MIRType) { MOZ_CRASH(); }
} // namespace jit
} // namespace js
#endif /* jit_none_BaselineHelpers_none_h */

35
js/src/jit/none/BaselineRegisters-none.h Normal file
Просмотреть файл

@ -0,0 +1,35 @@
/* -*- 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_none_BaselineRegisters_none_h
#define jit_none_BaselineRegisters_none_h
#include "jit/IonMacroAssembler.h"
namespace js {
namespace jit {
static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = { 0 };
static MOZ_CONSTEXPR_VAR Register BaselineStackReg = { 0 };
static MOZ_CONSTEXPR_VAR ValueOperand R0 = JSReturnOperand;
static MOZ_CONSTEXPR_VAR ValueOperand R1 = JSReturnOperand;
static MOZ_CONSTEXPR_VAR ValueOperand R2 = JSReturnOperand;
static MOZ_CONSTEXPR_VAR Register BaselineTailCallReg = { 0 };
static MOZ_CONSTEXPR_VAR Register BaselineStubReg = { 0 };
static MOZ_CONSTEXPR_VAR Register ExtractTemp0 = { 0 };
static MOZ_CONSTEXPR_VAR Register ExtractTemp1 = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0 = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1 = { 0 };
} // namespace jit
} // namespace js
#endif /* jit_none_BaselineRegisters_none_h */

61
js/src/jit/none/CodeGenerator-none.h Normal file
Просмотреть файл

@ -0,0 +1,61 @@
/* -*- 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_none_CodeGenerator_none_h
#define jit_none_CodeGenerator_none_h
#include "jit/shared/CodeGenerator-shared.h"
namespace js {
namespace jit {
class CodeGeneratorNone : public CodeGeneratorShared
{
public:
NonAssertingLabel returnLabel_;
CodeGeneratorNone(MIRGenerator *gen, LIRGraph *graph, MacroAssembler *masm)
: CodeGeneratorShared(gen, graph, masm)
{
MOZ_CRASH();
}
template <typename T> inline Register ToOperand(T) { MOZ_CRASH(); }
MoveOperand toMoveOperand(const LAllocation *) const { MOZ_CRASH(); }
template <typename T1, typename T2>
bool bailoutCmp32(Assembler::Condition, T1, T2, LSnapshot *) { MOZ_CRASH(); }
template<typename T>
bool bailoutTest32(Assembler::Condition, Register, T, LSnapshot *) { MOZ_CRASH(); }
template <typename T1, typename T2>
bool bailoutCmpPtr(Assembler::Condition, T1, T2, LSnapshot *) { MOZ_CRASH(); }
bool bailoutTestPtr(Assembler::Condition, Register, Register, LSnapshot *) { MOZ_CRASH(); }
bool bailoutIfFalseBool(Register, LSnapshot *) { MOZ_CRASH(); }
bool bailoutFrom(Label *, LSnapshot *) { MOZ_CRASH(); }
bool bailout(LSnapshot *) { MOZ_CRASH(); }
bool bailoutIf(Assembler::Condition, LSnapshot *) { MOZ_CRASH(); }
bool generatePrologue() { MOZ_CRASH(); }
bool generateEpilogue() { MOZ_CRASH(); }
bool generateOutOfLineCode() { MOZ_CRASH(); }
void testNullEmitBranch(Assembler::Condition, ValueOperand, MBasicBlock *, MBasicBlock *) {
MOZ_CRASH();
}
void testUndefinedEmitBranch(Assembler::Condition, ValueOperand, MBasicBlock *, MBasicBlock *) {
MOZ_CRASH();
}
bool emitTableSwitchDispatch(MTableSwitch *, Register, Register) { MOZ_CRASH(); }
ValueOperand ToValue(LInstruction *, size_t) { MOZ_CRASH(); }
ValueOperand ToOutValue(LInstruction *) { MOZ_CRASH(); }
ValueOperand ToTempValue(LInstruction *, size_t) { MOZ_CRASH(); }
bool generateInvalidateEpilogue() { MOZ_CRASH(); }
void postAsmJSCall(LAsmJSCall *) { MOZ_CRASH(); }
};
typedef CodeGeneratorNone CodeGeneratorSpecific;
} // namespace jit
} // namespace js
#endif /* jit_none_CodeGenerator_none_h */

53
js/src/jit/none/LIR-none.h Normal file
Просмотреть файл

@ -0,0 +1,53 @@
/* -*- 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_none_LIR_none_h
#define jit_none_LIR_none_h
namespace js {
namespace jit {
class LUnboxFloatingPoint : public LInstruction
{
public:
static const size_t Input = 0;
MUnbox *mir() const { MOZ_CRASH(); }
const LDefinition *output() const { MOZ_CRASH(); }
MIRType type() const { MOZ_CRASH(); }
};
class LTableSwitch : public LInstruction
{
public:
MTableSwitch *mir() { MOZ_CRASH(); }
const LAllocation *index() { MOZ_CRASH(); }
const LDefinition *tempInt() { MOZ_CRASH(); }
const LDefinition *tempPointer() { MOZ_CRASH(); }
};
class LTableSwitchV : public LInstruction
{
public:
MTableSwitch *mir() { MOZ_CRASH(); }
const LDefinition *tempInt() { MOZ_CRASH(); }
const LDefinition *tempFloat() { MOZ_CRASH(); }
const LDefinition *tempPointer() { MOZ_CRASH(); }
static const size_t InputValue = 0;
};
class LGuardShape : public LInstruction {};
class LGuardObjectType : public LInstruction {};
class LMulI : public LInstruction {};
} // namespace jit
} // namespace js
#endif /* jit_none_LIR_none_h */

12
js/src/jit/none/LOpcodes-none.h Normal file
Просмотреть файл

@ -0,0 +1,12 @@
/* -*- 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_none_LOpcodes_none_h__
#define jit_none_LOpcodes_none_h__
#define LIR_CPU_OPCODE_LIST(_)
#endif // jit_none_LOpcodes_none_h__

71
js/src/jit/none/Lowering-none.h Normal file
Просмотреть файл

@ -0,0 +1,71 @@
/* -*- 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_none_Lowering_none_h
#define jit_none_Lowering_none_h
#include "jit/shared/Lowering-shared.h"
namespace js {
namespace jit {
class LIRGeneratorNone : public LIRGeneratorShared
{
public:
LIRGeneratorNone(MIRGenerator *gen, MIRGraph &graph, LIRGraph &lirGraph)
: LIRGeneratorShared(gen, graph, lirGraph)
{
MOZ_CRASH();
}
bool useBox(LInstruction *, size_t, MDefinition *,
LUse::Policy a = LUse::REGISTER, bool b = false) {
MOZ_CRASH();
}
bool useBoxFixed(LInstruction *, size_t, MDefinition *, Register, Register) { MOZ_CRASH(); }
LAllocation useByteOpRegister(MDefinition *) { MOZ_CRASH(); }
LAllocation useByteOpRegisterOrNonDoubleConstant(MDefinition *) { MOZ_CRASH(); }
LDefinition tempToUnbox() { MOZ_CRASH(); }
bool needTempForPostBarrier() { MOZ_CRASH(); }
LDefinition tempForDispatchCache(MIRType v = MIRType_None) { MOZ_CRASH(); }
void lowerUntypedPhiInput(MPhi *, uint32_t, LBlock *, size_t) { MOZ_CRASH(); }
bool defineUntypedPhi(MPhi *, size_t) { MOZ_CRASH(); }
bool lowerForShift(LInstructionHelper<1, 2, 0> *, MDefinition *, MDefinition *, MDefinition *) {
MOZ_CRASH();
}
bool lowerUrshD(MUrsh *) { MOZ_CRASH(); }
template <typename T>
bool lowerForALU(T, MDefinition *, MDefinition *, MDefinition *v = nullptr) { MOZ_CRASH(); }
template <typename T>
bool lowerForFPU(T, MDefinition *, MDefinition *, MDefinition *v = nullptr) { MOZ_CRASH(); }
bool lowerForBitAndAndBranch(LBitAndAndBranch *, MInstruction *,
MDefinition *, MDefinition *) {
MOZ_CRASH();
}
bool lowerConstantDouble(double, MInstruction *) { MOZ_CRASH(); }
bool lowerConstantFloat32(float, MInstruction *) { MOZ_CRASH(); }
bool lowerTruncateDToInt32(MTruncateToInt32 *) { MOZ_CRASH(); }
bool lowerTruncateFToInt32(MTruncateToInt32 *) { MOZ_CRASH(); }
bool lowerDivI(MDiv *) { MOZ_CRASH(); }
bool lowerModI(MMod *) { MOZ_CRASH(); }
bool lowerMulI(MMul *, MDefinition *, MDefinition *) { MOZ_CRASH(); }
bool lowerUDiv(MDiv *) { MOZ_CRASH(); }
bool lowerUMod(MMod *) { MOZ_CRASH(); }
bool visitPowHalf(MPowHalf *) { MOZ_CRASH(); }
bool visitAsmJSNeg(MAsmJSNeg *) { MOZ_CRASH(); }
LTableSwitch *newLTableSwitch(LAllocation, LDefinition, MTableSwitch *) { MOZ_CRASH(); }
LTableSwitchV *newLTableSwitchV(MTableSwitch *) { MOZ_CRASH(); }
};
typedef LIRGeneratorNone LIRGeneratorSpecific;
} // namespace jit
} // namespace js
#endif /* jit_none_Lowering_none_h */

402
js/src/jit/none/MacroAssembler-none.h Normal file
Просмотреть файл

@ -0,0 +1,402 @@
/* -*- 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_none_MacroAssembler_none_h
#define jit_none_MacroAssembler_none_h
#include "jit/MoveResolver.h"
#include "jit/shared/Assembler-shared.h"
namespace js {
namespace jit {
static MOZ_CONSTEXPR_VAR Register StackPointer = { 0 };
static MOZ_CONSTEXPR_VAR Register FramePointer = { 0 };
static MOZ_CONSTEXPR_VAR Register ReturnReg = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = { 0 };
static MOZ_CONSTEXPR_VAR FloatRegister InvalidFloatReg = { 0 };
static MOZ_CONSTEXPR_VAR Register OsrFrameReg = { 0 };
static MOZ_CONSTEXPR_VAR Register ArgumentsRectifierReg = { 0 };
static MOZ_CONSTEXPR_VAR Register PreBarrierReg = { 0 };
static MOZ_CONSTEXPR_VAR Register CallTempReg0 = { 0 };
static MOZ_CONSTEXPR_VAR Register CallTempReg1 = { 0 };
static MOZ_CONSTEXPR_VAR Register CallTempReg2 = { 0 };
static MOZ_CONSTEXPR_VAR Register CallTempReg3 = { 0 };
static MOZ_CONSTEXPR_VAR Register CallTempReg4 = { 0 };
static MOZ_CONSTEXPR_VAR Register CallTempReg5 = { 0 };
static MOZ_CONSTEXPR_VAR Register InvalidReg = { 0 };
static MOZ_CONSTEXPR_VAR Register IntArgReg0 = { 0 };
static MOZ_CONSTEXPR_VAR Register IntArgReg1 = { 0 };
static MOZ_CONSTEXPR_VAR Register IntArgReg2 = { 0 };
static MOZ_CONSTEXPR_VAR Register IntArgReg3 = { 0 };
static MOZ_CONSTEXPR_VAR Register GlobalReg = { 0 };
static MOZ_CONSTEXPR_VAR Register HeapReg = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegCallee = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE0 = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE1 = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE2 = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE3 = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD0 = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD1 = { 0 };
static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD2 = { 0 };
static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = { 0 };
static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = { 0 };
static MOZ_CONSTEXPR_VAR Register JSReturnReg = { 0 };
#if defined(JS_NUNBOX32)
static MOZ_CONSTEXPR_VAR ValueOperand JSReturnOperand(InvalidReg, InvalidReg);
#elif defined(JS_PUNBOX64)
static MOZ_CONSTEXPR_VAR ValueOperand JSReturnOperand(InvalidReg);
#else
#error "Bad architecture"
#endif
static const uint32_t StackAlignment = 8;
static const uint32_t CodeAlignment = 4;
static const bool StackKeptAligned = false;
static const Scale ScalePointer = TimesOne;
class Assembler : public AssemblerShared
{
public:
enum Condition {
Equal,
NotEqual,
Above,
AboveOrEqual,
Below,
BelowOrEqual,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
Overflow,
Signed,
NotSigned,
Zero,
NonZero,
Always,
};
enum DoubleCondition {
DoubleOrdered,
DoubleEqual,
DoubleNotEqual,
DoubleGreaterThan,
DoubleGreaterThanOrEqual,
DoubleLessThan,
DoubleLessThanOrEqual,
DoubleUnordered,
DoubleEqualOrUnordered,
DoubleNotEqualOrUnordered,
DoubleGreaterThanOrUnordered,
DoubleGreaterThanOrEqualOrUnordered,
DoubleLessThanOrUnordered,
DoubleLessThanOrEqualOrUnordered
};
static Condition InvertCondition(Condition) { MOZ_CRASH(); }
template <typename T, typename S>
static void PatchDataWithValueCheck(CodeLocationLabel, T, S) { MOZ_CRASH(); }
static void PatchWrite_Imm32(CodeLocationLabel, Imm32) { MOZ_CRASH(); }
static void PatchWrite_NearCall(CodeLocationLabel, CodeLocationLabel) { MOZ_CRASH(); }
static uint32_t PatchWrite_NearCallSize() { MOZ_CRASH(); }
static void PatchInstructionImmediate(uint8_t *, PatchedImmPtr) { MOZ_CRASH(); }
static int32_t ExtractCodeLabelOffset(uint8_t *) { MOZ_CRASH(); }
static void ToggleToJmp(CodeLocationLabel) { MOZ_CRASH(); }
static void ToggleToCmp(CodeLocationLabel) { MOZ_CRASH(); }
static void ToggleCall(CodeLocationLabel, bool) { MOZ_CRASH(); }
static uintptr_t GetPointer(uint8_t *) { MOZ_CRASH(); }
};
class MacroAssemblerNone : public Assembler
{
public:
MacroAssemblerNone() { MOZ_CRASH(); }
MoveResolver moveResolver_;
size_t framePushed_;
uint32_t framePushed() const { MOZ_CRASH(); }
void setFramePushed(uint32_t) { MOZ_CRASH(); }
size_t size() const { MOZ_CRASH(); }
size_t bytesNeeded() const { MOZ_CRASH(); }
size_t jumpRelocationTableBytes() const { MOZ_CRASH(); }
size_t dataRelocationTableBytes() const { MOZ_CRASH(); }
size_t preBarrierTableBytes() const { MOZ_CRASH(); }
size_t numCodeLabels() const { MOZ_CRASH(); }
CodeLabel codeLabel(size_t) { MOZ_CRASH(); }
void trace(JSTracer *) { MOZ_CRASH(); }
static void TraceJumpRelocations(JSTracer *, JitCode *, CompactBufferReader &) { MOZ_CRASH(); }
static void TraceDataRelocations(JSTracer *, JitCode *, CompactBufferReader &) { MOZ_CRASH(); }
void executableCopy(void *) { MOZ_CRASH(); }
void copyJumpRelocationTable(uint8_t *) { MOZ_CRASH(); }
void copyDataRelocationTable(uint8_t *) { MOZ_CRASH(); }
void copyPreBarrierTable(uint8_t *) { MOZ_CRASH(); }
void processCodeLabels(uint8_t *) { MOZ_CRASH(); }
void flushBuffer() { MOZ_CRASH(); }
template <typename T> void bind(T) { MOZ_CRASH(); }
template <typename T> void j(Condition, T) { MOZ_CRASH(); }
template <typename T> void jump(T) { MOZ_CRASH(); }
void align(size_t) { MOZ_CRASH(); }
void checkStackAlignment() { MOZ_CRASH(); }
uint32_t currentOffset() { MOZ_CRASH(); }
uint32_t actualOffset(uint32_t) { MOZ_CRASH(); }
uint32_t labelOffsetToPatchOffset(uint32_t) { MOZ_CRASH(); }
CodeOffsetLabel labelForPatch() { MOZ_CRASH(); }
template <typename T> void call(T) { MOZ_CRASH(); }
template <typename T, typename S> void call(T, S) { MOZ_CRASH(); }
template <typename T> void callWithABI(T, MoveOp::Type v = MoveOp::GENERAL) { MOZ_CRASH(); }
void setupAlignedABICall(uint32_t) { MOZ_CRASH(); }
void setupUnalignedABICall(uint32_t, Register) { MOZ_CRASH(); }
template <typename T> void passABIArg(T, MoveOp::Type v = MoveOp::GENERAL) { MOZ_CRASH(); }
void callWithExitFrame(JitCode *) { MOZ_CRASH(); }
void callWithExitFrame(JitCode *, Register) { MOZ_CRASH(); }
void callIon(Register callee) { MOZ_CRASH(); }
void callIonFromAsmJS(Register callee) { MOZ_CRASH(); }
void nop() { MOZ_CRASH(); }
void breakpoint() { MOZ_CRASH(); }
void abiret() { MOZ_CRASH(); }
void ret() { MOZ_CRASH(); }
CodeOffsetLabel toggledJump(Label *) { MOZ_CRASH(); }
CodeOffsetLabel toggledCall(JitCode *, bool) { MOZ_CRASH(); }
static size_t ToggledCallSize(uint8_t *) { MOZ_CRASH(); }
void writePrebarrierOffset(CodeOffsetLabel) { MOZ_CRASH(); }
void finish() { MOZ_CRASH(); }
template <typename T, typename S> void moveValue(T, S) { MOZ_CRASH(); }
template <typename T, typename S, typename U> void moveValue(T, S, U) { MOZ_CRASH(); }
template <typename T, typename S> void storeValue(T, S) { MOZ_CRASH(); }
template <typename T, typename S, typename U> void storeValue(T, S, U) { MOZ_CRASH(); }
template <typename T, typename S> void loadValue(T, S) { MOZ_CRASH(); }
template <typename T> void pushValue(T) { MOZ_CRASH(); }
template <typename T, typename S> void pushValue(T, S) { MOZ_CRASH(); }
void popValue(ValueOperand) { MOZ_CRASH(); }
void tagValue(JSValueType, Register, ValueOperand) { MOZ_CRASH(); }
template <typename T> void push(T) { MOZ_CRASH(); }
template <typename T> void Push(T) { MOZ_CRASH(); }
template <typename T> void pop(T) { MOZ_CRASH(); }
template <typename T> void Pop(T) { MOZ_CRASH(); }
template <typename T> CodeOffsetLabel PushWithPatch(T) { MOZ_CRASH(); }
void implicitPop(uint32_t) { MOZ_CRASH(); }
CodeOffsetJump jumpWithPatch(RepatchLabel *) { MOZ_CRASH(); }
CodeOffsetJump jumpWithPatch(RepatchLabel *, Condition) { MOZ_CRASH(); }
template <typename T, typename S>
CodeOffsetJump branchPtrWithPatch(Condition, T, S, RepatchLabel *) { MOZ_CRASH(); }
template <typename T, typename S> void branchTestValue(Condition, T, S, Label *) { MOZ_CRASH(); }
void testNullSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
void testObjectSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
void testUndefinedSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
template <typename T, typename S> void cmpPtrSet(Condition, T, S, Register) { MOZ_CRASH(); }
template <typename T, typename S> void cmp32Set(Condition, T, S, Register) { MOZ_CRASH(); }
void reserveStack(uint32_t) { MOZ_CRASH(); }
template <typename T> void freeStack(T) { MOZ_CRASH(); }
template <typename T, typename S> void add32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void addPtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void sub32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void subPtr(T, S) { MOZ_CRASH(); }
void neg32(Register) { MOZ_CRASH(); }
void mulBy3(Register, Register) { MOZ_CRASH(); }
void negateDouble(FloatRegister) { MOZ_CRASH(); }
void addDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
void subDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
void mulDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
void divDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
template <typename T, typename S> void branch32(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchTest32(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchAdd32(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchSub32(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchPtr(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchTestPtr(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchDouble(DoubleCondition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchFloat(DoubleCondition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void branchPrivatePtr(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void decBranchPtr(Condition, T, S, Label *) { MOZ_CRASH(); }
template <typename T, typename S> void mov(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void movq(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void movePtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void move32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void moveFloat32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void moveDouble(T, S) { MOZ_CRASH(); }
template <typename T> CodeOffsetLabel movWithPatch(T, Register) { MOZ_CRASH(); }
template <typename T> void loadPtr(T, Register) { MOZ_CRASH(); }
template <typename T> void load32(T, Register) { MOZ_CRASH(); }
template <typename T> void loadFloat32(T, FloatRegister) { MOZ_CRASH(); }
template <typename T> void loadDouble(T, FloatRegister) { MOZ_CRASH(); }
template <typename T> void loadPrivate(T, Register) { MOZ_CRASH(); }
template <typename T> void load8SignExtend(T, Register) { MOZ_CRASH(); }
template <typename T> void load8ZeroExtend(T, Register) { MOZ_CRASH(); }
template <typename T> void load16SignExtend(T, Register) { MOZ_CRASH(); }
template <typename T> void load16ZeroExtend(T, Register) { MOZ_CRASH(); }
template <typename T, typename S> void storePtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void store32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void storeFloat32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void storeDouble(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void store8(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void store16(T, S) { MOZ_CRASH(); }
template <typename T> void computeEffectiveAddress(T, Register) { MOZ_CRASH(); }
void clampIntToUint8(Register) { MOZ_CRASH(); }
Register splitTagForTest(ValueOperand) { MOZ_CRASH(); }
template <typename T> void branchTestUndefined(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestInt32(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestBoolean(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestDouble(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestNull(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestString(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestSymbol(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestObject(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestNumber(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestGCThing(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestPrimitive(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestMagic(Condition, T, Label *) { MOZ_CRASH(); }
template <typename T> void branchTestMagicValue(Condition, T, JSWhyMagic, Label *) { MOZ_CRASH(); }
void boxDouble(FloatRegister, ValueOperand) { MOZ_CRASH(); }
void boxNonDouble(JSValueType, Register, ValueOperand) { MOZ_CRASH(); }
template <typename T> void unboxInt32(T, Register) { MOZ_CRASH(); }
template <typename T> void unboxBoolean(T, Register) { MOZ_CRASH(); }
template <typename T> void unboxString(T, Register) { MOZ_CRASH(); }
template <typename T> void unboxSymbol(T, Register) { MOZ_CRASH(); }
template <typename T> void unboxObject(T, Register) { MOZ_CRASH(); }
template <typename T> void unboxDouble(T, FloatRegister) { MOZ_CRASH(); }
void unboxValue(const ValueOperand &, AnyRegister) { MOZ_CRASH(); }
void notBoolean(ValueOperand) { MOZ_CRASH(); }
Register extractObject(Address, Register) { MOZ_CRASH(); }
Register extractObject(ValueOperand, Register) { MOZ_CRASH(); }
Register extractInt32(ValueOperand, Register) { MOZ_CRASH(); }
Register extractBoolean(ValueOperand, Register) { MOZ_CRASH(); }
template <typename T> Register extractTag(T, Register) { MOZ_CRASH(); }
void convertFloat32ToInt32(FloatRegister, Register, Label *, bool v = true) { MOZ_CRASH(); }
void convertDoubleToInt32(FloatRegister, Register, Label *, bool v = true) { MOZ_CRASH(); }
void convertBoolToInt32(Register, Register) { MOZ_CRASH(); }
void convertDoubleToFloat32(FloatRegister, FloatRegister) { MOZ_CRASH(); }
void convertInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); }
template <typename T> void convertInt32ToDouble(T, FloatRegister) { MOZ_CRASH(); }
void convertFloat32ToDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
void branchTruncateDouble(FloatRegister, Register, Label *) { MOZ_CRASH(); }
void branchTruncateFloat32(FloatRegister, Register, Label *) { MOZ_CRASH(); }
void boolValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
void boolValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
void int32ValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
void int32ValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
void loadConstantDouble(double, FloatRegister) { MOZ_CRASH(); }
void addConstantDouble(double, FloatRegister) { MOZ_CRASH(); }
void loadConstantFloat32(float, FloatRegister) { MOZ_CRASH(); }
void addConstantFloat32(float, FloatRegister) { MOZ_CRASH(); }
Condition testInt32Truthy(bool, ValueOperand) { MOZ_CRASH(); }
Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); }
void branchTestInt32Truthy(bool, ValueOperand, Label *) { MOZ_CRASH(); }
void branchTestBooleanTruthy(bool, ValueOperand, Label *) { MOZ_CRASH(); }
void branchTestStringTruthy(bool, ValueOperand, Label *) { MOZ_CRASH(); }
void branchTestDoubleTruthy(bool, FloatRegister, Label *) { MOZ_CRASH(); }
template <typename T> void loadUnboxedValue(T, MIRType, AnyRegister) { MOZ_CRASH(); }
template <typename T> void storeUnboxedValue(ConstantOrRegister, MIRType, T, MIRType) { MOZ_CRASH(); }
void rshiftPtr(Imm32, Register) { MOZ_CRASH(); }
void rshiftPtrArithmetic(Imm32, Register) { MOZ_CRASH(); }
void lshiftPtr(Imm32, Register) { MOZ_CRASH(); }
template <typename T, typename S> void xorPtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void xor32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void orPtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void or32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void andPtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void and32(T, S) { MOZ_CRASH(); }
template <typename T> void not32(T) { MOZ_CRASH(); }
void convertUInt32ToDouble(Register, FloatRegister) { MOZ_CRASH(); }
void convertUInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); }
void inc64(AbsoluteAddress) { MOZ_CRASH(); }
void incrementInt32Value(Address) { MOZ_CRASH(); }
void ensureDouble(ValueOperand, FloatRegister, Label *) { MOZ_CRASH(); }
void handleFailureWithHandler(void *) { MOZ_CRASH(); }
void makeFrameDescriptor(Register, FrameType) { MOZ_CRASH(); }
#ifdef JSGC_GENERATIONAL
void branchPtrInNurseryRange(Condition, Register, Register, Label *) { MOZ_CRASH(); }
void branchValueIsNurseryObject(Condition, ValueOperand, Register, Label *) { MOZ_CRASH(); }
#endif
bool buildFakeExitFrame(Register, uint32_t *) { MOZ_CRASH(); }
bool buildOOLFakeExitFrame(void *) { MOZ_CRASH(); }
void loadAsmJSActivation(Register) { MOZ_CRASH(); }
void memIntToValue(Address, Address) { MOZ_CRASH(); }
void setPrinter(Sprinter *) { MOZ_CRASH(); }
#ifdef JS_NUNBOX32
Address ToPayload(Address) { MOZ_CRASH(); }
Address ToType(Address) { MOZ_CRASH(); }
#endif
};
typedef MacroAssemblerNone MacroAssemblerSpecific;
class ABIArgGenerator
{
public:
ABIArgGenerator() { MOZ_CRASH(); }
ABIArg next(MIRType) { MOZ_CRASH(); }
ABIArg &current() { MOZ_CRASH(); }
uint32_t stackBytesConsumedSoFar() const { MOZ_CRASH(); }
static const Register NonArgReturnVolatileReg0;
static const Register NonArgReturnVolatileReg1;
};
static inline void PatchJump(CodeLocationJump &, CodeLocationLabel) { MOZ_CRASH(); }
static inline bool GetTempRegForIntArg(uint32_t, uint32_t, Register *) { MOZ_CRASH(); }
} // namespace jit
} // namespace js
#endif /* jit_none_MacroAssembler_none_h */

29
js/src/jit/none/MoveEmitter-none.h Normal file
Просмотреть файл

@ -0,0 +1,29 @@
/* -*- 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_none_MoveEmitter_none_h
#define jit_none_MoveEmitter_none_h
#include "jit/IonMacroAssembler.h"
#include "jit/MoveResolver.h"
namespace js {
namespace jit {
class MoveEmitterNone
{
public:
MoveEmitterNone(MacroAssemblerNone &) { MOZ_CRASH(); }
void emit(const MoveResolver &) { MOZ_CRASH(); }
void finish() { MOZ_CRASH(); }
};
typedef MoveEmitterNone MoveEmitter;
} // namespace jit
} // namespace js
#endif /* jit_none_MoveEmitter_none_h */

62
js/src/jit/none/Trampoline-none.cpp Normal file
Просмотреть файл

@ -0,0 +1,62 @@
/* -*- 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/. */
#include "jscompartment.h"
#include "jit/Bailouts.h"
#include "jit/BaselineIC.h"
#include "jit/IonCaches.h"
using namespace js;
using namespace js::jit;
// This file includes stubs for generating the JIT trampolines when there is no
// JIT backend, and also includes implementations for assorted random things
// which can't be implemented in headers.
JitCode *JitRuntime::generateEnterJIT(JSContext *, EnterJitType) { MOZ_CRASH(); }
JitCode *JitRuntime::generateInvalidator(JSContext *) { MOZ_CRASH(); }
JitCode *JitRuntime::generateArgumentsRectifier(JSContext *, ExecutionMode, void **) { MOZ_CRASH(); }
JitCode *JitRuntime::generateBailoutTable(JSContext *, uint32_t) { MOZ_CRASH(); }
JitCode *JitRuntime::generateBailoutHandler(JSContext *, ExecutionMode) { MOZ_CRASH(); }
JitCode *JitRuntime::generateVMWrapper(JSContext *, const VMFunction &) { MOZ_CRASH(); }
JitCode *JitRuntime::generatePreBarrier(JSContext *, MIRType) { MOZ_CRASH(); }
JitCode *JitRuntime::generateDebugTrapHandler(JSContext *) { MOZ_CRASH(); }
JitCode *JitRuntime::generateExceptionTailStub(JSContext *) { MOZ_CRASH(); }
JitCode *JitRuntime::generateBailoutTailStub(JSContext *) { MOZ_CRASH(); }
JitCode *JitRuntime::generateForkJoinGetSliceStub(JSContext *) { MOZ_CRASH(); }
FrameSizeClass FrameSizeClass::FromDepth(uint32_t) { MOZ_CRASH(); }
FrameSizeClass FrameSizeClass::ClassLimit() { MOZ_CRASH(); }
uint32_t FrameSizeClass::frameSize() const { MOZ_CRASH(); }
void DispatchIonCache::initializeAddCacheState(LInstruction *, AddCacheState *) { MOZ_CRASH(); }
void MacroAssembler::PushRegsInMask(RegisterSet) { MOZ_CRASH(); }
void MacroAssembler::clampDoubleToUint8(FloatRegister, Register) { MOZ_CRASH(); }
void MacroAssembler::PopRegsInMaskIgnore(RegisterSet, RegisterSet) { MOZ_CRASH(); }
void MacroAssembler::alignFrameForICArguments(AfterICSaveLive &) { MOZ_CRASH(); }
void MacroAssembler::restoreFrameAlignmentForICArguments(AfterICSaveLive &) { MOZ_CRASH(); }
const Register ABIArgGenerator::NonArgReturnVolatileReg0 = { 0 };
const Register ABIArgGenerator::NonArgReturnVolatileReg1 = { 0 };
IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &iter, BailoutStack *bailout)
: JitFrameIterator(iter)
{
MOZ_CRASH();
}
IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &iter, InvalidationBailoutStack *bailout)
: JitFrameIterator(iter)
{
MOZ_CRASH();
}
bool ICCompare_Int32::Compiler::generateStubCode(MacroAssembler &) { MOZ_CRASH(); }
bool ICCompare_Double::Compiler::generateStubCode(MacroAssembler &) { MOZ_CRASH(); }
bool ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler &) { MOZ_CRASH(); }
bool ICUnaryArith_Int32::Compiler::generateStubCode(MacroAssembler &) { MOZ_CRASH(); }

2
js/src/jsapi.cpp
Просмотреть файл

@ -6269,7 +6269,7 @@ JS_SetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt, uint32_t v
JS_PUBLIC_API(int)
JS_GetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt)
{
#ifdef JS_ION
#ifndef JS_CODEGEN_NONE
switch (opt) {
case JSJITCOMPILER_BASELINE_USECOUNT_TRIGGER:
return jit::js_JitOptions.baselineUsesBeforeCompile;

217
js/src/moz.build
Просмотреть файл

@ -129,12 +129,74 @@ UNIFIED_SOURCES += [
'gc/Tracer.cpp',
'gc/Verifier.cpp',
'gc/Zone.cpp',
'irregexp/NativeRegExpMacroAssembler.cpp',
'irregexp/RegExpAST.cpp',
'irregexp/RegExpEngine.cpp',
'irregexp/RegExpInterpreter.cpp',
'irregexp/RegExpMacroAssembler.cpp',
'irregexp/RegExpParser.cpp',
'irregexp/RegExpStack.cpp',
'jit/AliasAnalysis.cpp',
'jit/AsmJS.cpp',
'jit/AsmJSFrameIterator.cpp',
'jit/AsmJSLink.cpp',
'jit/AsmJSModule.cpp',
'jit/AsmJSSignalHandlers.cpp',
'jit/BacktrackingAllocator.cpp',
'jit/Bailouts.cpp',
'jit/BaselineBailouts.cpp',
'jit/BaselineCompiler.cpp',
'jit/BaselineDebugModeOSR.cpp',
'jit/BaselineFrame.cpp',
'jit/BaselineFrameInfo.cpp',
'jit/BaselineIC.cpp',
'jit/BaselineInspector.cpp',
'jit/BaselineJIT.cpp',
'jit/BitSet.cpp',
'jit/BytecodeAnalysis.cpp',
'jit/C1Spewer.cpp',
'jit/CodeGenerator.cpp',
'jit/CompileWrappers.cpp',
'jit/EdgeCaseAnalysis.cpp',
'jit/EffectiveAddressAnalysis.cpp',
'jit/Ion.cpp',
'jit/IonAnalysis.cpp',
'jit/IonBuilder.cpp',
'jit/IonCaches.cpp',
'jit/IonFrames.cpp',
'jit/IonMacroAssembler.cpp',
'jit/IonOptimizationLevels.cpp',
'jit/IonSpewer.cpp',
'jit/JitOptions.cpp',
'jit/JSONSpewer.cpp',
'jit/LICM.cpp',
'jit/LinearScan.cpp',
'jit/LIR.cpp',
'jit/LiveRangeAllocator.cpp',
'jit/Lowering.cpp',
'jit/MCallOptimize.cpp',
'jit/MIR.cpp',
'jit/MIRGraph.cpp',
'jit/MoveResolver.cpp',
'jit/ParallelFunctions.cpp',
'jit/ParallelSafetyAnalysis.cpp',
'jit/PerfSpewer.cpp',
'jit/RangeAnalysis.cpp',
'jit/Recover.cpp',
'jit/RegisterAllocator.cpp',
'jit/RematerializedFrame.cpp',
'jit/Safepoints.cpp',
'jit/ScalarReplacement.cpp',
'jit/shared/BaselineCompiler-shared.cpp',
'jit/shared/CodeGenerator-shared.cpp',
'jit/shared/Lowering-shared.cpp',
'jit/Snapshots.cpp',
'jit/StupidAllocator.cpp',
'jit/TypedObjectPrediction.cpp',
'jit/TypePolicy.cpp',
'jit/UnreachableCodeElimination.cpp',
'jit/ValueNumbering.cpp',
'jit/VMFunctions.cpp',
'jsalloc.cpp',
'jsapi.cpp',
'jsbool.cpp',
@ -245,120 +307,59 @@ if CONFIG['ENABLE_TRACE_LOGGING']:
'vm/TraceLogging.cpp',
]
if CONFIG['ENABLE_ION']:
if not CONFIG['ENABLE_ION']:
UNIFIED_SOURCES += [
'irregexp/NativeRegExpMacroAssembler.cpp',
'jit/AliasAnalysis.cpp',
'jit/AsmJS.cpp',
'jit/AsmJSFrameIterator.cpp',
'jit/AsmJSLink.cpp',
'jit/AsmJSModule.cpp',
'jit/AsmJSSignalHandlers.cpp',
'jit/BacktrackingAllocator.cpp',
'jit/Bailouts.cpp',
'jit/BaselineBailouts.cpp',
'jit/BaselineCompiler.cpp',
'jit/BaselineDebugModeOSR.cpp',
'jit/BaselineFrame.cpp',
'jit/BaselineFrameInfo.cpp',
'jit/BaselineIC.cpp',
'jit/BaselineInspector.cpp',
'jit/BaselineJIT.cpp',
'jit/BitSet.cpp',
'jit/BytecodeAnalysis.cpp',
'jit/C1Spewer.cpp',
'jit/CodeGenerator.cpp',
'jit/CompileWrappers.cpp',
'jit/EdgeCaseAnalysis.cpp',
'jit/EffectiveAddressAnalysis.cpp',
'jit/Ion.cpp',
'jit/IonAnalysis.cpp',
'jit/IonBuilder.cpp',
'jit/IonCaches.cpp',
'jit/IonFrames.cpp',
'jit/IonMacroAssembler.cpp',
'jit/IonOptimizationLevels.cpp',
'jit/IonSpewer.cpp',
'jit/JitOptions.cpp',
'jit/JSONSpewer.cpp',
'jit/LICM.cpp',
'jit/LinearScan.cpp',
'jit/LIR.cpp',
'jit/LiveRangeAllocator.cpp',
'jit/Lowering.cpp',
'jit/MCallOptimize.cpp',
'jit/MIR.cpp',
'jit/MIRGraph.cpp',
'jit/MoveResolver.cpp',
'jit/ParallelFunctions.cpp',
'jit/ParallelSafetyAnalysis.cpp',
'jit/PerfSpewer.cpp',
'jit/RangeAnalysis.cpp',
'jit/Recover.cpp',
'jit/RegisterAllocator.cpp',
'jit/RematerializedFrame.cpp',
'jit/Safepoints.cpp',
'jit/ScalarReplacement.cpp',
'jit/shared/BaselineCompiler-shared.cpp',
'jit/shared/CodeGenerator-shared.cpp',
'jit/shared/Lowering-shared.cpp',
'jit/Snapshots.cpp',
'jit/StupidAllocator.cpp',
'jit/TypedObjectPrediction.cpp',
'jit/TypePolicy.cpp',
'jit/UnreachableCodeElimination.cpp',
'jit/ValueNumbering.cpp',
'jit/VMFunctions.cpp',
'jit/none/Trampoline-none.cpp'
]
if CONFIG['JS_CODEGEN_X86'] or CONFIG['JS_CODEGEN_X64']:
elif CONFIG['JS_CODEGEN_X86'] or CONFIG['JS_CODEGEN_X64']:
UNIFIED_SOURCES += [
'jit/shared/Assembler-x86-shared.cpp',
'jit/shared/BaselineCompiler-x86-shared.cpp',
'jit/shared/BaselineIC-x86-shared.cpp',
'jit/shared/CodeGenerator-x86-shared.cpp',
'jit/shared/Lowering-x86-shared.cpp',
'jit/shared/MacroAssembler-x86-shared.cpp',
'jit/shared/MoveEmitter-x86-shared.cpp',
]
if CONFIG['JS_CODEGEN_X64']:
UNIFIED_SOURCES += [
'jit/shared/Assembler-x86-shared.cpp',
'jit/shared/BaselineCompiler-x86-shared.cpp',
'jit/shared/BaselineIC-x86-shared.cpp',
'jit/shared/CodeGenerator-x86-shared.cpp',
'jit/shared/Lowering-x86-shared.cpp',
'jit/shared/MacroAssembler-x86-shared.cpp',
'jit/shared/MoveEmitter-x86-shared.cpp',
'jit/x64/Assembler-x64.cpp',
'jit/x64/Bailouts-x64.cpp',
'jit/x64/BaselineCompiler-x64.cpp',
'jit/x64/BaselineIC-x64.cpp',
'jit/x64/CodeGenerator-x64.cpp',
'jit/x64/Lowering-x64.cpp',
'jit/x64/MacroAssembler-x64.cpp',
'jit/x64/Trampoline-x64.cpp',
]
if CONFIG['JS_CODEGEN_X64']:
UNIFIED_SOURCES += [
'jit/x64/Assembler-x64.cpp',
'jit/x64/Bailouts-x64.cpp',
'jit/x64/BaselineCompiler-x64.cpp',
'jit/x64/BaselineIC-x64.cpp',
'jit/x64/CodeGenerator-x64.cpp',
'jit/x64/Lowering-x64.cpp',
'jit/x64/MacroAssembler-x64.cpp',
'jit/x64/Trampoline-x64.cpp',
]
else:
UNIFIED_SOURCES += [
'jit/x86/Assembler-x86.cpp',
'jit/x86/Bailouts-x86.cpp',
'jit/x86/BaselineCompiler-x86.cpp',
'jit/x86/BaselineIC-x86.cpp',
'jit/x86/CodeGenerator-x86.cpp',
'jit/x86/Lowering-x86.cpp',
'jit/x86/MacroAssembler-x86.cpp',
'jit/x86/Trampoline-x86.cpp',
]
elif CONFIG['JS_CODEGEN_ARM']:
else:
UNIFIED_SOURCES += [
'jit/arm/Architecture-arm.cpp',
'jit/arm/Assembler-arm.cpp',
'jit/arm/Bailouts-arm.cpp',
'jit/arm/BaselineCompiler-arm.cpp',
'jit/arm/BaselineIC-arm.cpp',
'jit/arm/CodeGenerator-arm.cpp',
'jit/arm/Lowering-arm.cpp',
'jit/arm/MacroAssembler-arm.cpp',
'jit/arm/MoveEmitter-arm.cpp',
'jit/arm/Trampoline-arm.cpp',
'jit/x86/Assembler-x86.cpp',
'jit/x86/Bailouts-x86.cpp',
'jit/x86/BaselineCompiler-x86.cpp',
'jit/x86/BaselineIC-x86.cpp',
'jit/x86/CodeGenerator-x86.cpp',
'jit/x86/Lowering-x86.cpp',
'jit/x86/MacroAssembler-x86.cpp',
'jit/x86/Trampoline-x86.cpp',
]
elif CONFIG['JS_CODEGEN_ARM']:
UNIFIED_SOURCES += [
'jit/arm/Architecture-arm.cpp',
'jit/arm/Assembler-arm.cpp',
'jit/arm/Bailouts-arm.cpp',
'jit/arm/BaselineCompiler-arm.cpp',
'jit/arm/BaselineIC-arm.cpp',
'jit/arm/CodeGenerator-arm.cpp',
'jit/arm/Lowering-arm.cpp',
'jit/arm/MacroAssembler-arm.cpp',
'jit/arm/MoveEmitter-arm.cpp',
'jit/arm/Trampoline-arm.cpp',
]
if CONFIG['JS_ARM_SIMULATOR']:
UNIFIED_SOURCES += [
'jit/arm/Simulator-arm.cpp'
]
if CONFIG['JS_ARM_SIMULATOR']:
UNIFIED_SOURCES += [
'jit/arm/Simulator-arm.cpp'
]
if CONFIG['OS_ARCH'] == 'WINNT':
SOURCES += [

6
js/src/vm/ArrayBufferObject.cpp
Просмотреть файл

@ -409,7 +409,7 @@ ArrayBufferObject::changeContents(JSContext *cx, void *newData)
}
}
#if defined(JS_CPU_X64)
#if defined(JS_CODEGEN_X64)
// Refer to comment above AsmJSMappedSize in AsmJS.h.
JS_STATIC_ASSERT(AsmJSAllocationGranularity == AsmJSPageSize);
#endif
@ -437,7 +437,7 @@ ArrayBufferObject::releaseAsmJSArrayNoSignals(FreeOp *fop)
fop->free_(dataPointer());
}
#if defined(JS_ION) && defined(JS_CPU_X64)
#ifdef JS_CODEGEN_X64
/* static */ bool
ArrayBufferObject::prepareForAsmJS(JSContext *cx, Handle<ArrayBufferObject*> buffer,
bool usesSignalHandlers)
@ -524,7 +524,7 @@ ArrayBufferObject::releaseAsmJSArray(FreeOp *fop)
# endif
# endif
}
#else /* defined(JS_ION) && defined(JS_CPU_X64) */
#else // JS_CODEGEN_X64
bool
ArrayBufferObject::prepareForAsmJS(JSContext *cx, Handle<ArrayBufferObject*> buffer,
bool usesSignalHandlers)

4
js/src/vm/SharedArrayObject.cpp
Просмотреть файл

@ -77,7 +77,7 @@ SharedArrayRawBuffer::New(uint32_t length)
// Enforced by SharedArrayBufferObject constructor.
JS_ASSERT(IsValidAsmJSHeapLength(length));
#ifdef JS_CPU_X64
#ifdef JS_CODEGEN_X64
// Get the entire reserved region (with all pages inaccessible)
void *p = MapMemory(AsmJSMappedSize, false);
if (!p)
@ -124,7 +124,7 @@ SharedArrayRawBuffer::dropReference()
if (refcount == 0) {
uint8_t *p = this->dataPointer() - AsmJSPageSize;
JS_ASSERT(uintptr_t(p) % AsmJSPageSize == 0);
#ifdef JS_CPU_X64
#ifdef JS_CODEGEN_X64
UnmapMemory(p, AsmJSMappedSize);
# if defined(MOZ_VALGRIND) \
&& defined(VALGRIND_ENABLE_ADDR_ERROR_REPORTING_IN_RANGE)