Hello world works

Author: MikeHolman

lib/Backend/Backend.h

@@ -114,14 +114,14 @@ enum IRDumpFlags
 #include "ChakraJIT.h"
 #include "JITTimeProfileInfo.h"
 #include "CodeGenWorkItemType.h"
+#include "CodeGenAllocators.h"
 #include "ThreadContextInfo.h"
 #include "ScriptContextInfo.h"
 #include "JITOutput.h"
 #include "JITTimeScriptContext.h"
 #include "JITTimeFunctionBody.h"
 #include "JITTimeWorkItem.h"
 #include "NativeCodeData.h"
-#include "CodeGenAllocators.h"
 #include "IRType.h"
 #include "md.h"
 #include "..\Runtime\ByteCode\BackEndOpcodeAttr.h"

lib/Backend/CodeGenAllocators.cpp

@@ -4,13 +4,13 @@
 //-------------------------------------------------------------------------------------------------------
 #include "BackEnd.h"
 
-CodeGenAllocators::CodeGenAllocators(AllocationPolicyManager * policyManager, Js::ScriptContext * scriptContext)
+CodeGenAllocators::CodeGenAllocators(AllocationPolicyManager * policyManager, Js::ScriptContext * scriptContext, HANDLE processHandle)
 : pageAllocator(policyManager, Js::Configuration::Global.flags, PageAllocatorType_BGJIT,
                 (AutoSystemInfo::Data.IsLowMemoryProcess() ?
                  PageAllocator::DefaultLowMaxFreePageCount :
                  PageAllocator::DefaultMaxFreePageCount))
 , allocator(L"NativeCode", &pageAllocator, Js::Throw::OutOfMemory)
-, emitBufferManager(policyManager, &allocator, scriptContext, L"JIT code buffer", ALLOC_XDATA)
+, emitBufferManager(policyManager, &allocator, scriptContext, L"JIT code buffer", ALLOC_XDATA, processHandle)
 #if !_M_X64_OR_ARM64 && _CONTROL_FLOW_GUARD
 , canCreatePreReservedSegment(false)
 #endif

lib/Backend/CodeGenAllocators.h

@@ -24,7 +24,7 @@ struct CodeGenAllocators
     size_t staticNativeCodeData;
 #endif
 
-    CodeGenAllocators(AllocationPolicyManager * policyManager, Js::ScriptContext * scriptContext);
+    CodeGenAllocators(AllocationPolicyManager * policyManager, Js::ScriptContext * scriptContext, HANDLE processHandle);
     PageAllocator *GetPageAllocator() { return &pageAllocator; };
     ~CodeGenAllocators();
 };

lib/Backend/CodeGenWorkItem.cpp

@@ -311,50 +311,6 @@ void CodeGenWorkItem::OnRemoveFromJitQueue(NativeCodeGenerator* generator)
     }
 }
 
-void CodeGenWorkItem::RecordNativeCodeSize(Func *func, size_t bytes, ushort pdataCount, ushort xdataSize)
-{
-    BYTE *buffer;
-#if defined(_M_ARM32_OR_ARM64)
-    bool canAllocInPreReservedHeapPageSegment = false;
-#else
-    bool canAllocInPreReservedHeapPageSegment = func->CanAllocInPreReservedHeapPageSegment();
-#endif
-    EmitBufferAllocation *allocation = func->GetEmitBufferManager()->AllocateBuffer(bytes, &buffer, pdataCount, xdataSize, canAllocInPreReservedHeapPageSegment, true);
-
-#if DBG
-    MEMORY_BASIC_INFORMATION memBasicInfo;
-    size_t resultBytes = VirtualQuery(allocation->allocation->address, &memBasicInfo, sizeof(memBasicInfo));
-    Assert(resultBytes != 0 && memBasicInfo.Protect == PAGE_EXECUTE);
-#endif
-
-    Assert(allocation != nullptr);
-    if (buffer == nullptr)
-        Js::Throw::OutOfMemory();
-
-    SetCodeAddress((size_t)buffer);
-    SetCodeSize(bytes);
-    SetPdataCount(pdataCount);
-    SetXdataSize(xdataSize);
-    SetAllocation(allocation);
-}
-
-void CodeGenWorkItem::RecordNativeCode(Func *func, const BYTE* sourceBuffer)
-{
-    if (!func->GetEmitBufferManager()->CommitBuffer(this->GetAllocation(), (BYTE *)GetCodeAddress(), GetCodeSize(), sourceBuffer))
-    {
-        Js::Throw::OutOfMemory();
-    }
-
-    this->isAllocationCommitted = true;
-
-#if DBG_DUMP
-    if (Type() == JsLoopBodyWorkItemType)
-    {
-        func->GetEmitBufferManager()->totalBytesLoopBody += GetCodeSize();
-    }
-#endif
-}
-
 void CodeGenWorkItem::OnWorkItemProcessFail(NativeCodeGenerator* codeGen)
 {
     if (!isAllocationCommitted && this->allocation != nullptr && this->allocation->allocation != nullptr)

lib/Backend/CodeGenWorkItem.h

@@ -134,9 +134,6 @@ struct CodeGenWorkItem : public JsUtil::Job
         return this->entryPointInfo;
     }
 
-    void RecordNativeCodeSize(Func *func, size_t bytes, ushort pdataCount, ushort xdataSize);
-    void RecordNativeCode(Func *func, const BYTE* sourceBuffer);
-
     Js::CodeGenRecyclableData *RecyclableData() const
     {
         return recyclableData;
@@ -193,25 +190,6 @@ struct CodeGenWorkItem : public JsUtil::Job
         return jitData.isJitInDebugMode != 0;
     }
 
-#if _M_X64 || _M_ARM
-    size_t RecordUnwindInfo(size_t offset, BYTE *unwindInfo, size_t size)
-    {
-#if _M_X64
-        Assert(offset == 0);
-        Assert(XDATA_SIZE >= size);
-        js_memcpy_s(GetAllocation()->allocation->xdata.address, XDATA_SIZE, unwindInfo, size);
-        return 0;
-#else
-        BYTE *xdataFinal = GetAllocation()->allocation->xdata.address + offset;
-
-        Assert(xdataFinal);
-        Assert(((DWORD)xdataFinal & 0x3) == 0); // 4 byte aligned
-        js_memcpy_s(xdataFinal, size, unwindInfo, size);
-        return (size_t)xdataFinal;
-#endif
-    }
-#endif
-
 #if _M_ARM
     void RecordPdataEntry(int index, DWORD beginAddress, DWORD unwindData)
     {
@@ -251,9 +229,6 @@ struct JsFunctionCodeGen sealed : public CodeGenWorkItem
         bool isJitInDebugMode)
         : CodeGenWorkItem(manager, functionBody, entryPointInfo, isJitInDebugMode, JsFunctionType)
     {
-        auto funcEPInfo = (Js::FunctionEntryPointInfo*)entryPointInfo;
-        this->jitData.readOnlyEPData.callsCountAddress = (uintptr_t)&funcEPInfo->callsCount;
-
         size_t sizeInChars = this->GetDisplayName(nullptr, 256);
 
         WCHAR * displayName = HeapNewArray(WCHAR, sizeInChars);

lib/Backend/EmitBuffer.cpp

@@ -13,11 +13,12 @@ template class EmitBufferManager<CriticalSection>;
 //----------------------------------------------------------------------------
 template <typename SyncObject>
 EmitBufferManager<SyncObject>::EmitBufferManager(AllocationPolicyManager * policyManager, ArenaAllocator * allocator,
-    Js::ScriptContext * scriptContext, LPCWSTR name, bool allocXdata) :
-    allocationHeap(policyManager, allocator, allocXdata),
+    Js::ScriptContext * scriptContext, LPCWSTR name, bool allocXdata, HANDLE processHandle) :
+    allocationHeap(policyManager, allocator, allocXdata, processHandle),
     allocator(allocator),
     allocations(nullptr),
-    scriptContext(scriptContext)
+    scriptContext(scriptContext),
+    processHandle(processHandle)
 {
 #if DBG_DUMP
     this->totalBytesCode = 0;
@@ -154,11 +155,6 @@ EmitBufferManager<SyncObject>::NewAllocation(size_t bytes, ushort pdataCount, us
     bool isAllJITCodeInPreReservedRegion = true;
     CustomHeap::Allocation* heapAllocation = this->allocationHeap.Alloc(bytes, pdataCount, xdataSize, canAllocInPreReservedHeapPageSegment, isAnyJittedCode, &isAllJITCodeInPreReservedRegion);
 
-    if (!isAllJITCodeInPreReservedRegion)
-    {
-        this->scriptContext->GetThreadContext()->ResetIsAllJITCodeInPreReservedRegion();
-    }
-
     if (heapAllocation  == nullptr)
     {
         // This is used in interpreter scenario, thus we need to try to recover memory, if possible.
@@ -181,6 +177,7 @@ EmitBufferManager<SyncObject>::NewAllocation(size_t bytes, ushort pdataCount, us
     allocation->bytesUsed = 0;
     allocation->nextAllocation = this->allocations;
     allocation->recorded = false;
+    allocation->inPrereservedRegion = isAllJITCodeInPreReservedRegion;
 
     this->allocations = allocation;
 
@@ -300,7 +297,7 @@ EmitBufferAllocation* EmitBufferManager<SyncObject>::AllocateBuffer(__in size_t
 
 #if DBG
     MEMORY_BASIC_INFORMATION memBasicInfo;
-    size_t resultBytes = VirtualQuery(allocation->allocation->address, &memBasicInfo, sizeof(memBasicInfo));
+    size_t resultBytes = VirtualQueryEx(this->processHandle, allocation->allocation->address, &memBasicInfo, sizeof(memBasicInfo));
     Assert(resultBytes != 0 && memBasicInfo.Protect == PAGE_EXECUTE);
 #endif
 
@@ -421,7 +418,7 @@ EmitBufferManager<SyncObject>::CommitBuffer(EmitBufferAllocation* allocation, __
         if (alignPad != 0)
         {
             DWORD alignBytes = alignPad < spaceInCurrentPage ? alignPad : spaceInCurrentPage;
-            CustomHeap::FillDebugBreak(currentDestBuffer, alignBytes);
+            CustomHeap::FillDebugBreak(currentDestBuffer, alignBytes, this->processHandle);
 
             alignPad -= alignBytes;
             currentDestBuffer += alignBytes;
@@ -439,7 +436,7 @@ EmitBufferManager<SyncObject>::CommitBuffer(EmitBufferAllocation* allocation, __
         {
             AssertMsg(alignPad == 0, "If we are copying right now - we should be done with setting alignment.");
 
-            memcpy_s(currentDestBuffer, allocation->BytesFree(), sourceBuffer, bytesToChange);
+            ChakraMemCopy(currentDestBuffer, allocation->BytesFree(), sourceBuffer, bytesToChange, this->processHandle);
 
             currentDestBuffer += bytesToChange;
             sourceBuffer += bytesToChange;

lib/Backend/EmitBuffer.h

@@ -12,6 +12,7 @@ struct EmitBufferAllocation
     CustomHeap::Allocation* allocation;
     size_t bytesUsed;
     size_t bytesCommitted;
+    bool   inPrereservedRegion;
     bool   recorded;
     EmitBufferAllocation * nextAllocation;
 
@@ -30,7 +31,7 @@ template <class SyncObject = FakeCriticalSection>
 class EmitBufferManager
 {
 public:
-    EmitBufferManager(AllocationPolicyManager * policyManager, ArenaAllocator * allocator, Js::ScriptContext * scriptContext, LPCWSTR name, bool allocXdata);
+    EmitBufferManager(AllocationPolicyManager * policyManager, ArenaAllocator * allocator, Js::ScriptContext * scriptContext, LPCWSTR name, bool allocXdata, HANDLE processHandle);
     ~EmitBufferManager();
 
     // All the following methods are guarded with the SyncObject
@@ -126,6 +127,7 @@ class EmitBufferManager
     CustomHeap::Heap allocationHeap;
 
     SyncObject  criticalSection;
+    HANDLE processHandle;
 #if DBG_DUMP
 
 public:

lib/Backend/Encoder.cpp

@@ -239,11 +239,13 @@ Encoder::Encode()
         }
     }
 #endif
+#if 0 // TODO: michhol OOP JIT, understand this code
     for (int32 i = 0; i < m_pragmaInstrToRecordMap->Count(); i ++)
     {
         IR::PragmaInstr *inst = m_pragmaInstrToRecordMap->Item(i);
         inst->RecordThrowMap(iter, inst->m_offsetInBuffer);
     }
+#endif
 
     JITTimeWorkItem * workItem = m_func->GetWorkItem();
 
@@ -271,33 +273,38 @@ Encoder::Encode()
 
     TryCopyAndAddRelocRecordsForSwitchJumpTableEntries(m_encodeBuffer, codeSize, jumpTableListForSwitchStatement, totalJmpTableSizeInBytes);
 
-    workItem->RecordNativeCodeSize(m_func, (DWORD)codeSize, pdataCount, xdataSize);
+    EmitBufferAllocation * alloc = m_func->GetJITOutput()->RecordNativeCodeSize(m_func, (DWORD)codeSize, pdataCount, xdataSize);
+
+    if (!alloc->inPrereservedRegion)
+    {
+        m_func->GetThreadContextInfo()->ResetIsAllJITCodeInPreReservedRegion();
+    }
 
     this->m_bailoutRecordMap->MapAddress([=](int index, LazyBailOutRecord* record)
     {
         this->m_encoderMD.AddLabelReloc((BYTE*)&record->instructionPointer);
     });
 
     // Relocs
-    m_encoderMD.ApplyRelocs((size_t) workItem->GetCodeAddress());
-
-    workItem->RecordNativeCode(m_func, m_encodeBuffer);
+    m_encoderMD.ApplyRelocs((size_t)alloc->allocation->address);
 
-    m_func->GetScriptContext()->GetThreadContext()->SetValidCallTargetForCFG((PVOID) workItem->GetCodeAddress());
+    m_func->GetJITOutput()->RecordNativeCode(m_func, m_encodeBuffer, alloc);
 
 #ifdef _M_X64
     m_func->m_prologEncoder.FinalizeUnwindInfo();
-    workItem->RecordUnwindInfo(0, m_func->m_prologEncoder.GetUnwindInfo(), m_func->m_prologEncoder.SizeOfUnwindInfo());
+    m_func->GetJITOutput()->RecordUnwindInfo(
+        0,
+        m_func->m_prologEncoder.GetUnwindInfo(),
+        m_func->m_prologEncoder.SizeOfUnwindInfo(),
+        alloc->allocation->xdata.address,
+        m_func->GetThreadContextInfo()->GetProcessHandle());
 #elif _M_ARM
     m_func->m_unwindInfo.EmitUnwindInfo(workItem);
     workItem->SetCodeAddress(workItem->GetCodeAddress() | 0x1); // Set thumb mode
 #endif
 
-    Js::EntryPointInfo* entryPointInfo = this->m_func->m_workItem->GetEntryPoint();
+    Js::EntryPointInfo* entryPointInfo = nullptr;
     const bool isSimpleJit = m_func->IsSimpleJit();
-    Assert(
-        isSimpleJit ||
-        entryPointInfo->GetJitTransferData() != nullptr && !entryPointInfo->GetJitTransferData()->GetIsReady());
 
     if (this->m_inlineeFrameMap->Count() > 0 &&
         !(this->m_inlineeFrameMap->Count() == 1 && this->m_inlineeFrameMap->Item(0).record == nullptr))
@@ -477,13 +484,7 @@ Encoder::Encode()
 
         entryPointInfo->RecordCtorCacheGuards(ctorCachesTransferRecord, ctorCachesTransferSize);
     }
-
-    if(!isSimpleJit)
-    {
-        entryPointInfo->GetJitTransferData()->SetIsReady();
-    }
-
-    workItem->FinalizeNativeCode(m_func);
+    m_func->GetJITOutput()->FinalizeNativeCode(m_func, alloc);
 
     END_CODEGEN_PHASE(m_func, Js::EmitterPhase);
 
@@ -503,9 +504,9 @@ Encoder::Encode()
             __analysis_assume(m_instrNumber < instrCount);
             instr->DumpGlobOptInstrString();
 #ifdef _WIN64
-            Output::Print(L"%12IX  ", m_offsetBuffer[m_instrNumber++] + (BYTE *)workItem->GetCodeAddress());
+            Output::Print(L"%12IX  ", m_offsetBuffer[m_instrNumber++] + (BYTE *)m_func->GetJITOutput()->GetCodeAddress());
 #else
-            Output::Print(L"%8IX  ", m_offsetBuffer[m_instrNumber++] + (BYTE *)workItem->GetCodeAddress());
+            Output::Print(L"%8IX  ", m_offsetBuffer[m_instrNumber++] + (BYTE *)m_func->GetJITOutput()->GetCodeAddress());
 #endif
             instr->Dump();
         } NEXT_INSTR_IN_FUNC;
@@ -518,7 +519,7 @@ Encoder::Encode()
     {
         workItem->DumpNativeOffsetMaps();
         workItem->DumpNativeThrowSpanSequence();
-        this->DumpInlineeFrameMap(workItem->GetCodeAddress());
+        this->DumpInlineeFrameMap(m_func->GetJITOutput()->GetCodeAddress());
         Output::Flush();
     }
 #endif

lib/Backend/Func.cpp

@@ -9,6 +9,7 @@
 Func::Func(JitArenaAllocator *alloc, JITTimeWorkItem * workItem,
     ThreadContextInfo * threadContextInfo,
     ScriptContextInfo * scriptContextInfo,
+    JITOutputData * outputData,
     const Js::FunctionCodeGenJitTimeData *const jitTimeData,
     const Js::FunctionCodeGenRuntimeData *const runtimeData,
     Js::PolymorphicInlineCacheInfo * const polymorphicInlineCacheInfo, CodeGenAllocators *const codeGenAllocators,
@@ -19,6 +20,7 @@ Func::Func(JitArenaAllocator *alloc, JITTimeWorkItem * workItem,
     m_alloc(alloc),
     m_workItem(workItem),
     m_jitTimeData(jitTimeData),
+    m_output(outputData),
     m_threadContextInfo(threadContextInfo),
     m_scriptContextInfo(scriptContextInfo),
     m_runtimeData(runtimeData),
@@ -299,6 +301,7 @@ Func::Codegen()
             this->m_fg = nullptr;
         }
 
+        Dump();
 #ifdef IR_VIEWER
         IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::GlobOptPhase);
 #endif /* IR_VIEWER */
@@ -309,6 +312,7 @@ Func::Codegen()
         lowerer.Lower();
         END_CODEGEN_PHASE(this, Js::LowererPhase);
 
+        Dump();
 #ifdef IR_VIEWER
         IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::LowererPhase);
 #endif /* IR_VIEWER */

lib/Backend/Func.h

@@ -70,6 +70,7 @@ class Func
     Func(JitArenaAllocator *alloc, JITTimeWorkItem * workItem,
         ThreadContextInfo * threadContextInfo,
         ScriptContextInfo * scriptContextInfo,
+        JITOutputData * outputData,
         const Js::FunctionCodeGenJitTimeData *const jitTimeData, const Js::FunctionCodeGenRuntimeData *const runtimeData,
         Js::PolymorphicInlineCacheInfo * const polymorphicInlineCacheInfo, CodeGenAllocators *const codeGenAllocators,
         CodeGenNumberAllocator * numberAllocator, JITTimeProfileInfo *const profileInfo,
@@ -175,6 +176,11 @@ class Func
         return m_scriptContextInfo;
     }
 
+    JITOutput* GetJITOutput()
+    {
+        return &m_output;
+    }
+
     const JITTimeFunctionBody * const GetJITFunctionBody() const
     {
         return m_workItem->GetJITFunctionBody();