Feature/capture (#4625)

* Add decoder

* Add a replay executable to consume the decoded content

Add file-processor.cpp/h where we implement the logic to process
the captured file block by block. Each block is:
function header + parameter buffer + function tailer + function
output[optional].

After reading one block, the block of data is sent to decoder module
to dispatch the corresponding API.

Add slang-decoder.cpp/h where we implement the logic to dispatch
the slang API according to the input block data.

- Rename api_callId.h to capture-format.h
- Renmae capture_utility.cpp to capture-utility.cpp
- Renmae capture_utility.h to capture-utility.h
- Change the #include file name accordingly.

* Reorganize source files structure

Move all the capture logic code into `capture` directory.
 - the capture code will be build with slang dll.

Move all the replay logic code into `relay` directoy.
 - the replay code is not part of slang dll, it will be built
   as a stand alone binary and link against slang dll.

Change the #include file names accordingly.

Add tools/slang-replay/main.cpp for the slang-replay stand alone
binary place holder. Will implement it later.

Update premake5.lua accordingly.

* Update cmake files

Update cmake files to change the build process for
capture and relay system.

 - capture component should be build with slang dll, so we
   should not include replay component.
 - replay component should be a separate executable tool, which
   should not include capture component.
 - In order to easy use our current cmake infrastructure, move
   the shared files to a `util` folder
 - change the header include path

* Redesgin the interfaces of consumers

Fix some issues in capture
Finish implementing all slang-decoder functions

* Fix the AppleClang build issue

* Address few comments

- Fix the weird indent issues.
- Correct the function name for CreateGlobalSession()
- Rename file-processor to captureFile-processor to be more specific.
- Use Slang::List instead of std::vector

* record/replay: name refactor change

Refactor the naming.

Change the name "encoder/capture" to "record".

1 files changed, 60 insertions, 0 deletions

diff --git a/source/slang-record-replay/replay/decoder-helper.cpp b/source/slang-record-replay/replay/decoder-helper.cpp
new file mode 100644
index 000000000..c9252bbc6
--- /dev/null
+++ b/source/slang-record-replay/replay/decoder-helper.cpp
@@ -0,0 +1,60 @@
+#include <cstdlib>
+#include <vector>
+#include "decoder-helper.h"
+#include "parameter-decoder.h"
+
+namespace SlangRecord
+{
+    DecoderAllocatorSingleton* DecoderAllocatorSingleton::getInstance()
+    {
+        thread_local DecoderAllocatorSingleton instance;
+        return &instance;
+    }
+
+    void* DecoderAllocatorSingleton::allocate(size_t size)
+    {
+        void* data = calloc(1, size);
+
+        if (!data)
+        {
+            slangRecordLog(LogLevel::Error, "Failed to allocate memory\n");
+            std::abort();
+        }
+
+        m_allocations.add(data);
+        return data;
+    }
+
+    DecoderAllocatorSingleton::~DecoderAllocatorSingleton()
+    {
+        for (auto allocation : m_allocations)
+        {
+            free(allocation);
+        }
+    }
+
+    template <typename T, typename U>
+    size_t StructDecoder<T, U>::decode(const uint8_t* buffer, int64_t bufferSize)
+    {
+        return ParameterDecoder::decodeStruct(buffer, bufferSize, *this);
+    }
+
+    size_t BlobDecoder::decode(const uint8_t* buffer, int64_t bufferSize)
+    {
+        size_t readByte = 0;
+        readByte = ParameterDecoder::decodeAddress(buffer, bufferSize, m_address);
+
+        if (!m_address)
+        {
+            readByte += ParameterDecoder::decodePointer(buffer + readByte, bufferSize - readByte, m_blobData);
+        }
+        return readByte;
+    }
+
+    template class StructDecoder<slang::SessionDesc>;
+    template class StructDecoder<slang::PreprocessorMacroDesc>;
+    template class StructDecoder<slang::CompilerOptionEntry>;
+    template class StructDecoder<slang::CompilerOptionValue>;
+    template class StructDecoder<slang::TargetDesc>;
+    template class StructDecoder<slang::SpecializationArg>;
+}