1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#include <stdlib.h>
#include "dllexport.h"
class JitConfigProvider
{
public:
virtual int getIntConfigValue(
const wchar_t* name,
int defaultValue
) = 0;
virtual int getStringConfigValue(
const wchar_t* name,
wchar_t* retBuffer,
int retBufferLength
) = 0;
};
// Native implementation of the JIT host.
// The native implementation calls into JitConfigProvider (implemented on the managed side) to get the actual
// configuration values.
// This dance is necessary because RyuJIT calls into the JitHost as part of the process shutdown (to free up
// strings). JitHost therefore can't be implemented in managed code (because managed runtime might have
// already shut down).
class JitHost
{
JitConfigProvider* pConfigProvider;
public:
JitHost(JitConfigProvider* pConfigProvider)
: pConfigProvider(pConfigProvider) { }
virtual void* allocateMemory(size_t size)
{
return malloc(size);
}
virtual void freeMemory(void* block)
{
free(block);
}
virtual int getIntConfigValue(
const wchar_t* name,
int defaultValue
)
{
return pConfigProvider->getIntConfigValue(name, defaultValue);
}
virtual const wchar_t* getStringConfigValue(
const wchar_t* name
)
{
// Find out the required length of the buffer
int numCharacters = pConfigProvider->getStringConfigValue(name, nullptr, 0);
if (numCharacters == 0)
return nullptr;
// Allocate extra char for the null terminator
wchar_t* retBuffer = (wchar_t*)calloc(numCharacters + 1, sizeof(wchar_t));
pConfigProvider->getStringConfigValue(name, retBuffer, numCharacters);
return retBuffer;
}
virtual void freeStringConfigValue(
wchar_t* value
)
{
free(value);
}
virtual void* allocateSlab(size_t size, size_t* pActualSize)
{
*pActualSize = size;
return allocateMemory(size);
}
virtual void freeSlab(void* slab, size_t actualSize)
{
freeMemory(slab);
}
};
DLL_EXPORT void* GetJitHost(JitConfigProvider* pConfigProvider)
{
return new JitHost(pConfigProvider);
}
|
