%(PreprocessorDefinitions);

DISABLE_JIT=1

</PreprocessorDefinitions>

<PreprocessorDefinitions Condition="'$(IntlICU)'=='true'">

%(PreprocessorDefinitions);

INTL_ICU=1

<Import Project="$(ChakraDevConfigDir)\Chakra.Build.user.props" Condition="exists('$(ChakraDevConfigDir)\Chakra.Build.user.props')"/>

</ImportGroup>

<!-- Common build settings -->

<PropertyGroup>

<DebugBuild />

<OutBaseDir Condition="'$(OutBaseDir)'!=''">$(OutBaseDir)\$(SolutionName)</OutBaseDir>

<OutBaseDir Condition="'$(OutBaseDir)'==''">$(SolutionDir)VcBuild</OutBaseDir>

<OutBaseDir Condition="'$(Clang)'!=''">$(OutBaseDir).$(Clang)</OutBaseDir>

<OutBaseDir Condition="'$(ForceSWB)'=='true'">$(OutBaseDir).SWB</OutBaseDir>

<IntBaseDir Condition="'$(IntBaseDir)'==''">$(OutBaseDir)</IntBaseDir>

</PropertyGroup>

<ProjectReference Include="..\..\lib\Runtime\ByteCode\Chakra.Runtime.ByteCode.vcxproj">

<Project>{706083f7-6aa4-4558-a153-6352ef9110f5}</Project>

</ProjectReference>

<Project>{8C61E4E7-F0D6-420D-A352-3E6E50D406DD}</Project>

</ProjectReference>

<ProjectReference Include="..\..\lib\Runtime\Language\Chakra.Runtime.Language.vcxproj">

#include "stdafx.h"

#include "Core/AtomLockGuids.h"

#ifdef _WIN32

#include <winver.h>

#include <process.h>

#define IfFalseGo(expr) do { if(!(expr)) { hr = E_FAIL; goto Error; } } while(0)

#define IfFalseGoLabel(expr, label) do { if(!(expr)) { hr = E_FAIL; goto label; } } while(0)

#include "CommonDefines.h"

#include <map>

#include <string>

#include <CommonPal.h>

#include <stdarg.h>

#ifdef _MSC_VER

#include "Backend.h"

#include "Debug/DebuggingFlags.h"

#include "Debug/DiagProbe.h"

#include "Debug/DebugManager.h"

#include "Language/JavascriptFunctionArgIndex.h"

extern const IRType RegTypes[RegNumCount];

// Clear the disable implicit call bit in case we bail from that region

functionScriptContext->GetThreadContext()->ClearDisableImplicitFlags();

bool isInDebugMode = executeFunction->IsInDebugMode();

AssertMsg(!isInDebugMode || Js::Configuration::Global.EnableJitInDebugMode(),

"In diag mode we can get here (function has to be JIT'ed) only when EnableJitInDiagMode is true!");

}

}

}

#if defined(DBG_DUMP) || defined(ENABLE_DEBUG_CONFIG_OPTIONS)

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

#endif

{

// Following _AddressOfReturnAddress <= real address of "returnAddress". Suffices for RemoteStackWalker to test partially initialized interpreter frame.

Js::InterpreterStackFrame::PushPopFrameHelper pushPopFrameHelper(newInstance, returnAddress, _AddressOfReturnAddress());

aReturn = isInDebugMode ? newInstance->DebugProcess() : newInstance->Process();

// Note: in debug mode we always have to bailout to debug thunk,

// as normal interpreter thunk expects byte code compiled w/o debugging.

}

Js::ScriptFunction ** functionRef = (Js::ScriptFunction **)&layout->functionObject;

Js::ScriptFunction * function = *functionRef;

Js::FunctionBody * executeFunction = function->GetFunctionBody();

bool isInDebugMode = executeFunction->IsInDebugMode();

Js::JavascriptGenerator* generator = static_cast<Js::JavascriptGenerator*>(layout->args[0]);

Js::InterpreterStackFrame* frame = generator->GetFrame();

{

// Following _AddressOfReturnAddress <= real address of "returnAddress". Suffices for RemoteStackWalker to test partially initialized interpreter frame.

Js::InterpreterStackFrame::PushPopFrameHelper pushPopFrameHelper(frame, _ReturnAddress(), _AddressOfReturnAddress());

aReturn = isInDebugMode ? frame->DebugProcess() : frame->Process();

// Note: in debug mode we always have to bailout to debug thunk,

// as normal interpreter thunk expects byte code compiled w/o debugging.

}

}

#endif

static intptr_t const helperMethodWrappers[] = {

reinterpret_cast<intptr_t>(&Js::HelperMethodWrapper0),

reinterpret_cast<intptr_t>(&Js::HelperMethodWrapper1),

reinterpret_cast<intptr_t>(&Js::HelperMethodWrapper15),

reinterpret_cast<intptr_t>(&Js::HelperMethodWrapper16),

};

GetMethodAddress(ThreadContextInfo * context, IR::HelperCallOpnd* opnd)

{

Assert(opnd);

#if defined(_M_ARM32_OR_ARM64)

#define LowererMDFinal LowererMD

#else

AssertMsg(FALSE, "Unsupported arg count (need to implement).");

}

}

return GetMethodOriginalAddress(context, opnd->m_fnHelper);

}

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

#include "Backend.h"

#include "Debug/DebuggingFlags.h"

#include "Debug/DiagProbe.h"

#include "Debug/DebugManager.h"

// Parser includes

#include "RegexCommon.h"

LowerBailOnNegative(instr);

break;

case Js::OpCode::BailForDebugger:

instrPrev = this->LowerBailForDebugger(instr);

break;

case Js::OpCode::BailOnNotObject:

instrPrev = this->LowerBailOnNotObject(instr);

Assert(branchInstr->m_opcode == Js::OpCode::BrTrue_A || branchInstr->m_opcode == Js::OpCode::BrFalse_A);

if (branchInstr->HasBailOutInfo())

{

IR::BailOutKind debuggerBailOutKind = IR::BailOutInvalid;

if (branchInstr->HasAuxBailOut())

{

debuggerBailOutKind = branchInstr->GetAuxBailOutKind() & IR::BailOutForDebuggerBits;

AssertMsg((debuggerBailOutKind & ~(IR::BailOutIgnoreException | IR::BailOutForceByFlag)) == 0, "Only IR::BailOutIgnoreException|ForceByFlag supported here.");

}

IR::Instr * bailOutInstr = this->SplitBailOnImplicitCall(branchInstr, helperCall, branchInstr);

IR::Instr* prevInstr = this->LowerBailOnEqualOrNotEqual(bailOutInstr, branchInstr, nullptr, nullptr, isHelper);

if (debuggerBailOutKind != IR::BailOutInvalid)

{

// Note that by this time implicit calls bailout is already lowered.

this->LowerBailForDebugger(debuggerBailoutInstr, isHelper);

// After lowering this we will have a check which on bailout condition will JMP to $L11.

}

}

return m_lowererMD.LowerCondBranch(branchInstr);

return prevInstr;

}

IR::Instr *

Lowerer::LowerBailForDebugger(IR::Instr* instr, bool isInsideHelper /* = false */)

{

return prevInstr;

}

IR::Instr*

Lowerer::LowerBailOnException(IR::Instr * instr)

return m_isPRNGSeeded;

}

ServerScriptContext::GetDebuggingFlagsAddr() const

{

{

return static_cast<intptr_t>(m_contextData.debugScriptIdWhenSetAddr);

}

ServerScriptContext::IsClosed() const

virtual bool IsClosed() const override;

virtual intptr_t GetBuiltinFunctionsBaseAddr() const override;

virtual intptr_t GetDebuggingFlagsAddr() const override;

virtual intptr_t GetDebugStepTypeAddr() const override;

virtual intptr_t GetDebugFrameAddressAddr() const override;

virtual intptr_t GetDebugScriptIdWhenSetAddr() const override;

virtual intptr_t GetAddr() const override;