[reflection] Fix MethodInfo.GetBaseDefinition for open constructed types (close #36305)
Turns off the garbage collection in Mono. This should be only used
for debugging purposes
.TP
-\fBLVM_COUNT\fR
+\fBHTTP_PROXY\fR
+(Also \fBhttp_proxy\fR) If set, web requests using the Mono
+Class Library will be automatically proxied through the given URL.
+Not supported on Windows, Mac OS, iOS or Android. See also \fBNO_PROXY\fR.
+.TP
+\fBLLVM_COUNT\fR
When Mono is compiled with LLVM support, this instructs the runtime to
stop using LLVM after the specified number of methods are JITed.
This is a tool used in diagnostics to help isolate problems in the
at all. The other possible values are 'offline', which performs CRL check (not
implemented yet) and 'online' which uses OCSP and CRL to verify the revocation
status (not implemented yet).
+.TP
+\fBNO_PROXY\fR
+(Also \fBno_proxy\fR) If both \fBHTTP_PROXY\fR and \fBNO_PROXY\fR are
+set, \fBNO_PROXY\fR will be treated as a comma-separated list of "bypass" domains
+which will not be sent through the proxy. Domains in \fBNO_PROXY\fR may contain
+wildcards, as in "*.mono-project.com" or "build????.local". Not supported on
+Windows, Mac OS, iOS or Android.
.SH ENVIRONMENT VARIABLES FOR DEBUGGING
.TP
\fBMONO_ASPNET_NODELETE\fR
if (path.StartsWith (appvpath))
path = path.Substring (appvpath.Length);
- if (path [0] == '/')
+ if (path.StartsWith("/"))
path = path.Length > 1 ? path.Substring (1) : "";
return Canonic (appvpath + "(" + id + ")/" + path);
<Parameters />
<Docs>
<remarks>
- <attribution license="cc4" from="Microsoft" modified="false" />
- <para>
- <see cref="M:System.Net.WebRequest.GetSystemWebProxy" /> method reads the current user's Internet Explorer (IE) proxy settings. This process includes the IE options to automatically detect proxy settings, use an automatic configuration script, manual proxy server settings, and advanced manual proxy server settings.</para>
+ <attribution license="cc4" from="Microsoft" modified="true" />
+ <para><see cref="M:System.Net.WebRequest.GetSystemWebProxy" /> creates an appropriate proxy object for the current user.</para>
+ <para>On Windows, the method reads the current user's Internet Explorer (IE) proxy settings. The settings supported on Mono are proxy enabled, proxy URL, and proxy excluded domains.</para>
+ <para>On UNIX-like systems (but not including Mac OS, iOS, or Android), the method reads the environment variables "MONO_PROXY" (or "mono_proxy") and "NO_PROXY" (or "no_proxy"). See the mono man page for more information.</para>
<para>If your application is impersonating several users, you can use the <see cref="M:System.Net.WebRequest.GetSystemWebProxy" /> method to retrieve a proxy for each impersonated user.</para>
</remarks>
<summary>
public bool Enabled;
public bool NoWildcards;
public DateTime DisabledTime;
+
+ public object FilesLock = new object ();
public Hashtable Files;
}
files = NoStringsArray;
}
+ lock (data.FilesLock) {
+ IterateAndModifyFilesData (data, directory, dispatch, files);
+ }
+ }
+
+ void IterateAndModifyFilesData (DefaultWatcherData data, string directory, bool dispatch, string[] files)
+ {
/* Set all as untested */
foreach (string filename in data.Files.Keys) {
FileData fd = (FileData) data.Files [filename];
using System.Net.Cache;
using System.Security.Principal;
using System.Threading.Tasks;
+using System.Text.RegularExpressions;
#if NET_2_1
using ConfigurationException = System.ArgumentException;
throw GetMustImplement ();
}
+ // Takes an ArrayList of fileglob-formatted strings and returns an array of Regex-formatted strings
+ private static string[] CreateBypassList (ArrayList al)
+ {
+ string[] result = al.ToArray (typeof (string)) as string[];
+ for (int c = 0; c < result.Length; c++)
+ {
+ result [c] = "^" +
+ Regex.Escape (result [c]).Replace (@"\*", ".*").Replace (@"\?", ".") +
+ "$";
+ }
+ return result;
+ }
+
[MonoTODO("Look in other places for proxy config info")]
public static IWebProxy GetSystemWebProxy ()
{
}
}
- return new WebProxy (strHttpProxy, bBypassOnLocal, al.ToArray (typeof(string)) as string[]);
+ return new WebProxy (strHttpProxy, bBypassOnLocal, CreateBypassList (al));
}
} else {
#endif
}
}
- return new WebProxy (uri, bBypassOnLocal, al.ToArray (typeof(string)) as string[]);
+ return new WebProxy (uri, bBypassOnLocal, CreateBypassList (al));
} catch (UriFormatException) {
}
}
[ComVisible (true)]
[MonoTODO ("X509ContentType.SerializedCert isn't supported (anywhere in the class)")]
- public partial class X509Certificate : IDeserializationCallback, ISerializable {
+ public partial class X509Certificate : IDeserializationCallback, ISerializable, IDisposable {
private string issuer_name;
private string subject_name;
info.AddValue ("RawData", x509.RawData);
}
+ public void Dispose ()
+ {
+ Dispose (true);
+ }
+
+ protected virtual void Dispose (bool disposing)
+ {
+ if (disposing)
+ Reset ();
+ }
+
[ComVisible (false)]
public virtual void Reset ()
{
[TestFixture]
public class ThreadPoolTests
{
+ int minWorkerThreads;
+ int minCompletionPortThreads;
+ int maxWorkerThreads;
+ int maxCompletionPortThreads;
+
+ [SetUp]
+ public void SetUp ()
+ {
+ ThreadPool.GetMinThreads (out minWorkerThreads, out minCompletionPortThreads);
+ ThreadPool.GetMaxThreads (out maxWorkerThreads, out maxCompletionPortThreads);
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ ThreadPool.SetMinThreads (minWorkerThreads, minCompletionPortThreads);
+ ThreadPool.SetMaxThreads (maxWorkerThreads, maxCompletionPortThreads);
+ }
+
[Test]
public void RegisterWaitForSingleObject_InvalidArguments ()
{
ThreadPool.UnsafeQueueUserWorkItem (e, null);
Assert.IsTrue (ev.Wait (3000));
}
+
+ [Test]
+ public void SetAndGetMinThreads ()
+ {
+ int workerThreads, completionPortThreads;
+ int workerThreads_new, completionPortThreads_new;
+
+ ThreadPool.GetMinThreads (out workerThreads, out completionPortThreads);
+ Assert.IsTrue (workerThreads > 0, "#1");
+ Assert.IsTrue (completionPortThreads > 0, "#2");
+
+ workerThreads_new = workerThreads == 1 ? 2 : 1;
+ completionPortThreads_new = completionPortThreads == 1 ? 2 : 1;
+
+ ThreadPool.SetMinThreads (workerThreads_new, completionPortThreads_new);
+ ThreadPool.GetMinThreads (out workerThreads, out completionPortThreads);
+ Assert.IsTrue (workerThreads == workerThreads_new, "#3");
+ Assert.IsTrue (completionPortThreads == completionPortThreads_new, "#4");
+ }
+
+ [Test]
+ public void SetAndGetMaxThreads ()
+ {
+ int cpuCount = Environment.ProcessorCount;
+ int workerThreads, completionPortThreads;
+ int workerThreads_new, completionPortThreads_new;
+
+ ThreadPool.GetMaxThreads (out workerThreads, out completionPortThreads);
+ Assert.IsTrue (workerThreads > 0, "#1");
+ Assert.IsTrue (completionPortThreads > 0, "#2");
+
+ workerThreads_new = workerThreads == cpuCount ? cpuCount + 1 : cpuCount;
+ completionPortThreads_new = completionPortThreads == cpuCount ? cpuCount + 1 : cpuCount;
+
+ ThreadPool.SetMaxThreads (workerThreads_new, completionPortThreads_new);
+ ThreadPool.GetMaxThreads (out workerThreads, out completionPortThreads);
+ Assert.IsTrue (workerThreads == workerThreads_new, "#3");
+ Assert.IsTrue (completionPortThreads == completionPortThreads_new, "#4");
+ }
+
+ [Test]
+ public void GetAvailableThreads ()
+ {
+ ManualResetEvent mre = new ManualResetEvent (false);
+ DateTime start = DateTime.Now;
+ int i, workerThreads, completionPortThreads;
+
+ try {
+ while (true) {
+ ThreadPool.GetAvailableThreads (out workerThreads, out completionPortThreads);
+ if (workerThreads == 0)
+ break;
+
+ if ((DateTime.Now - start).TotalSeconds >= 10)
+ Assert.Fail ("did not reach 0 available threads");
+
+ ThreadPool.QueueUserWorkItem (GetAvailableThreads_Callback, mre);
+ Thread.Sleep (1);
+ }
+ } finally {
+ mre.Set ();
+ }
+ }
+
+ void GetAvailableThreads_Callback (object state)
+ {
+ ManualResetEvent mre = (ManualResetEvent) state;
+
+ if (mre.WaitOne (0))
+ return;
+
+ ThreadPool.QueueUserWorkItem (GetAvailableThreads_Callback, mre);
+ ThreadPool.QueueUserWorkItem (GetAvailableThreads_Callback, mre);
+ ThreadPool.QueueUserWorkItem (GetAvailableThreads_Callback, mre);
+ ThreadPool.QueueUserWorkItem (GetAvailableThreads_Callback, mre);
+
+ mre.WaitOne ();
+ }
}
}
\ No newline at end of file
{
Error(String.Format("[Fail] {0}", ret));
}
+ return;
}
// on Windows, we have to pipe the output of a
#endif
if (mh->num_clauses) {
- trys = g_malloc0 (sizeof (gboolean) * mh->num_clauses);
+ trys = (gboolean *)g_malloc0 (sizeof (gboolean) * mh->num_clauses);
trys [0] = 1;
for (i=1; i < mh->num_clauses; ++i) {
#define jcl mh->clauses [j]
for (i = 1; i <= t->rows; i++){
guint32 cols [MONO_METHODIMPL_SIZE];
- char *class, *impl, *decl;
+ char *klass, *impl, *decl;
mono_metadata_decode_row (t, i - 1, cols, MONO_METHODIMPL_SIZE);
- class = get_typedef (m, cols [MONO_METHODIMPL_CLASS]);
+ klass = get_typedef (m, cols [MONO_METHODIMPL_CLASS]);
impl = get_method (m, method_dor_to_token (cols [MONO_METHODIMPL_BODY]), NULL);
decl = get_method (m, method_dor_to_token (cols [MONO_METHODIMPL_DECLARATION]), NULL);
- fprintf (output, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i, class, decl, impl);
- g_free (class);
+ fprintf (output, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i, klass, decl, impl);
+ g_free (klass);
g_free (impl);
g_free (decl);
}
char *res, *eres, *result;
int i;
- res = g_malloc ((len >> 1) + 1);
+ res = (char *)g_malloc ((len >> 1) + 1);
/*
* I should really use some kind of libunicode here
for (i = 0; i < container->type_argc; i++) {
MonoGenericParam *param = mono_generic_container_get_param (container, i);
- if ((p = g_hash_table_lookup (table, mono_generic_param_info (param)->name)))
+ if ((p = (gpointer *)g_hash_table_lookup (table, mono_generic_param_info (param)->name)))
dup_list = g_slist_prepend (g_slist_prepend (dup_list, GUINT_TO_POINTER (i + 1)), p);
else
g_hash_table_insert (table, (char*)mono_generic_param_info (param)->name, GUINT_TO_POINTER (i + 1));
static void
dis_nt_header (MonoImage *m)
{
- MonoCLIImageInfo *image_info = m->image_info;
+ MonoCLIImageInfo *image_info = (MonoCLIImageInfo *)m->image_info;
if (image_info && image_info->cli_header.nt.pe_stack_reserve != 0x100000)
fprintf (output, ".stackreserve 0x%x\n", image_info->cli_header.nt.pe_stack_reserve);
}
if ((crow = mono_metadata_get_constant_index (m, MONO_TOKEN_FIELD_DEF | (i+1), 0))) {
mono_metadata_decode_row (&m->tables [MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
- lit = get_constant (m, const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
+ lit = get_constant (m, (MonoTypeEnum)const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
} else {
lit = g_strdup ("not found");
}
if ((crow = mono_metadata_get_constant_index(m, MONO_TOKEN_PARAM_DEF | i, 0))) {
guint32 const_cols [MONO_CONSTANT_SIZE];
mono_metadata_decode_row( &m->tables[MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
- lit = get_constant(m, const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
+ lit = get_constant (m, (MonoTypeEnum)const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
}
else {
lit = g_strdup ("not found");
const char *name = mono_image_get_name (image);
for (item = filter_list; item; item = item->next) {
- ifilter = item->data;
+ ifilter = (ImageFilter *)item->data;
if (strcmp (ifilter->name, name) == 0) {
cur_filter = ifilter;
return;
static int
int_cmp (const void *e1, const void *e2)
{
- const int *i1 = e1;
- const int *i2 = e2;
+ const int *i1 = (const int *)e1;
+ const int *i2 = (const int *)e2;
return *i1 - *i2;
}
GList *item;
for (item = filter_list; item; item = item->next) {
- ifilter = item->data;
+ ifilter = (ImageFilter *)item->data;
if (strcmp (ifilter->name, name) == 0)
return ifilter;
}
if (tf->count >= tf->size) {
if (!tf->size) {
tf->size = 8;
- tf->elems = g_malloc (sizeof (int) * tf->size);
+ tf->elems = (int *)g_malloc (sizeof (int) * tf->size);
} else {
tf->size *= 2;
- tf->elems = g_realloc (tf->elems, sizeof (int) * tf->size);
+ tf->elems = (int *)g_realloc (tf->elems, sizeof (int) * tf->size);
}
}
tf->elems [tf->count++] = val;
GList *item;
for (item = filter_list; item; item = item->next) {
- ifilter = item->data;
+ ifilter = (ImageFilter *)item->data;
qsort (ifilter->types.elems, ifilter->types.count, sizeof (int), int_cmp);
qsort (ifilter->fields.elems, ifilter->fields.count, sizeof (int), int_cmp);
qsort (ifilter->methods.elems, ifilter->methods.count, sizeof (int), int_cmp);
GList *tmp;
for (tmp = loaded_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (mono_assembly_names_equal (aname, &ass->aname))
return ass;
}
* If we just have one file, use the corlib version it requires.
*/
if (!input_files->next) {
- char *filename = input_files->data;
+ char *filename = (char *)input_files->data;
mono_init_from_assembly (argv [0], filename);
mono_init (argv [0]);
for (l = input_files; l; l = l->next)
- disassemble_file (l->data);
+ disassemble_file ((const char *)l->data);
}
return 0;
static void event_ops_init (void)
{
_wapi_handle_register_capabilities (WAPI_HANDLE_EVENT,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SIGNAL);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SIGNAL));
_wapi_handle_register_capabilities (WAPI_HANDLE_NAMEDEVENT,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SIGNAL);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SIGNAL));
}
static void event_signal(gpointer handle)
static void (*_wapi_handle_ops_get_close_func (WapiHandleType type))(gpointer, gpointer);
-static WapiHandleCapability handle_caps[WAPI_HANDLE_COUNT]={0};
+static WapiHandleCapability handle_caps[WAPI_HANDLE_COUNT] = { (WapiHandleCapability)0 };
static struct _WapiHandleOps *handle_ops[WAPI_HANDLE_COUNT]={
NULL,
&_wapi_file_ops,
_wapi_shm_semaphores_init ();
- _wapi_shared_layout = _wapi_shm_attach (WAPI_SHM_DATA);
+ _wapi_shared_layout = (_WapiHandleSharedLayout *)_wapi_shm_attach (WAPI_SHM_DATA);
g_assert (_wapi_shared_layout != NULL);
if (_wapi_shm_enabled ()) {
/* This allocates a 4mb array, so do it only if SHM is enabled */
- _wapi_fileshare_layout = _wapi_shm_attach (WAPI_SHM_FILESHARE);
+ _wapi_fileshare_layout = (_WapiFileShareLayout *)_wapi_shm_attach (WAPI_SHM_FILESHARE);
g_assert (_wapi_fileshare_layout != NULL);
}
static gint
wapi_share_info_equal (gconstpointer ka, gconstpointer kb)
{
- const _WapiFileShare *s1 = ka;
- const _WapiFileShare *s2 = kb;
+ const _WapiFileShare *s1 = (const _WapiFileShare *)ka;
+ const _WapiFileShare *s2 = (const _WapiFileShare *)kb;
return (s1->device == s2->device && s1->inode == s2->inode) ? 1 : 0;
}
static guint
wapi_share_info_hash (gconstpointer data)
{
- const _WapiFileShare *s = data;
+ const _WapiFileShare *s = (const _WapiFileShare *)data;
return s->inode;
}
file_share_hash_lock ();
- file_share = g_hash_table_lookup (file_share_hash, &tmp);
+ file_share = (_WapiFileShare *)g_hash_table_lookup (file_share_hash, &tmp);
if (file_share) {
*old_sharemode = file_share->sharemode;
*old_access = file_share->access;
gpointer CreateFile(const gunichar2 *name, guint32 fileaccess,
guint32 sharemode, WapiSecurityAttributes *security,
guint32 createmode, guint32 attrs,
- gpointer template G_GNUC_UNUSED)
+ gpointer template_ G_GNUC_UNUSED)
{
struct _WapiHandle_file file_handle = {0};
gpointer handle;
mode_t perms=0666;
gchar *filename;
int fd, ret;
- int handle_type;
+ WapiHandleType handle_type;
struct stat statbuf;
mono_once (&io_ops_once, io_ops_init);
if (state->mountpoint_allocated) {
if (state->mountpoint_index >= state->allocated_size) {
guint32 newsize = (state->allocated_size << 1) + 1;
- gchar *newbuf = g_malloc0 (newsize * sizeof (gchar));
+ gchar *newbuf = (gchar *)g_malloc0 (newsize * sizeof (gchar));
memcpy (newbuf, state->mountpoint_allocated, state->mountpoint_index);
g_free (state->mountpoint_allocated);
} else {
if (state->mountpoint_index >= GET_LOGICAL_DRIVE_STRINGS_MOUNTPOINT_BUFFER) {
state->allocated_size = (state->mountpoint_index << 1) + 1;
- state->mountpoint_allocated = g_malloc0 (state->allocated_size * sizeof (gchar));
+ state->mountpoint_allocated = (gchar *)g_malloc0 (state->allocated_size * sizeof (gchar));
memcpy (state->mountpoint_allocated, state->mountpoint, state->mountpoint_index);
state->mountpoint_allocated [state->mountpoint_index++] = ch;
} else
ErrorDesc d, *result;
d.id = id;
- result = mono_binary_search (&d, base, n, sizeof (ErrorDesc), msg_compare);
+ result = (ErrorDesc *)mono_binary_search (&d, base, n, sizeof (ErrorDesc), msg_compare);
if (result == NULL)
return NULL;
return result->txt;
static void mutex_ops_init (void)
{
_wapi_handle_register_capabilities (WAPI_HANDLE_MUTEX,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SIGNAL |
- WAPI_HANDLE_CAP_OWN);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SIGNAL | WAPI_HANDLE_CAP_OWN));
_wapi_handle_register_capabilities (WAPI_HANDLE_NAMEDMUTEX,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SIGNAL |
- WAPI_HANDLE_CAP_OWN);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SIGNAL | WAPI_HANDLE_CAP_OWN));
}
static void mutex_signal(gpointer handle)
WapiHandle_process process_handle = {0};
_wapi_handle_register_capabilities (WAPI_HANDLE_PROCESS,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SPECIAL_WAIT);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SPECIAL_WAIT));
process_handle.id = pid;
}
for (i = 0; i < count; i++) {
- free_procmodule (g_slist_nth_data (mods, i));
+ free_procmodule ((WapiProcModule *)g_slist_nth_data (mods, i));
}
g_slist_free (mods);
g_free (proc_name);
* they have the 'finished' flag set, which means the sigchld handler is done
* accessing them.
*/
- mp = l->data;
+ mp = (MonoProcess *)l->data;
mono_os_sem_destroy (&mp->exit_sem);
g_free (mp);
}
static void sem_ops_init (void)
{
_wapi_handle_register_capabilities (WAPI_HANDLE_SEM,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SIGNAL);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SIGNAL));
_wapi_handle_register_capabilities (WAPI_HANDLE_NAMEDSEM,
- WAPI_HANDLE_CAP_WAIT |
- WAPI_HANDLE_CAP_SIGNAL);
+ (WapiHandleCapability)(WAPI_HANDLE_CAP_WAIT | WAPI_HANDLE_CAP_SIGNAL));
}
static void sema_signal(gpointer handle)
* https://bugzilla.novell.com/show_bug.cgi?id=MONO53992
*/
{
- int ret, true = 1;
+ int ret, true_ = 1;
- ret = setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &true,
- sizeof (true));
+ ret = setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &true_,
+ sizeof (true_));
if (ret == -1) {
int errnum = errno;
}
if (i_len > 0) {
- buffer = g_memdup (input, i_len);
+ buffer = (char *)g_memdup (input, i_len);
}
ret = ioctl (fd, command, buffer);
string_value != NULL &&
string_value_len != 0) {
*buffer = string_value;
- *len = unicode_chars (string_value) + 1; /* Include trailing null */
+ *len = unicode_chars ((const gunichar2 *)string_value) + 1; /* Include trailing null */
ret = TRUE;
goto done;
}
struct _WapiHandleShared handles[_WAPI_HANDLE_INITIAL_COUNT];
};
+typedef struct _WapiHandleSharedLayout _WapiHandleSharedLayout;
+
#define _WAPI_FILESHARE_SIZE 102400
struct _WapiFileShare
struct _WapiFileShare share_info[_WAPI_FILESHARE_SIZE];
};
+typedef struct _WapiFileShareLayout _WapiFileShareLayout;
+
#define _WAPI_HANDLE_INVALID (gpointer)-1
const gchar *p;
newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
- pathv = pglob->gl_pathv ? realloc((char *)pglob->gl_pathv, newsize) :
- malloc(newsize);
+ /* FIXME: Can just use realloc(). */
+ pathv = (char **)(pglob->gl_pathv ? realloc((char *)pglob->gl_pathv, newsize) :
+ malloc(newsize));
if (pathv == NULL) {
if (pglob->gl_pathv) {
free(pglob->gl_pathv);
;
len = (size_t)(p - path);
*limitp += len;
- if ((copy = malloc(len)) != NULL) {
+ if ((copy = (char *)malloc(len)) != NULL) {
if (g_Ctoc(path, copy, len)) {
free(copy);
return(WAPI_GLOB_NOSPACE);
mono_install_assembly_refonly_preload_hook (mono_domain_assembly_preload, GUINT_TO_POINTER (TRUE));
mono_install_assembly_search_hook (mono_domain_assembly_search, GUINT_TO_POINTER (FALSE));
mono_install_assembly_refonly_search_hook (mono_domain_assembly_search, GUINT_TO_POINTER (TRUE));
- mono_install_assembly_postload_search_hook ((void*)mono_domain_assembly_postload_search, GUINT_TO_POINTER (FALSE));
- mono_install_assembly_postload_refonly_search_hook ((void*)mono_domain_assembly_postload_search, GUINT_TO_POINTER (TRUE));
+ mono_install_assembly_postload_search_hook ((MonoAssemblySearchFunc)mono_domain_assembly_postload_search, GUINT_TO_POINTER (FALSE));
+ mono_install_assembly_postload_refonly_search_hook ((MonoAssemblySearchFunc)mono_domain_assembly_postload_search, GUINT_TO_POINTER (TRUE));
mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
o = (MonoObject *)add->setup->shadow_copy_files;
else
- o = mono_g_hash_table_lookup (add->env, name);
+ o = (MonoObject *)mono_g_hash_table_lookup (add->env, name);
mono_domain_unlock (add);
g_free (str);
gpointer user_data,
GError **error)
{
- RuntimeConfig *runtime_config = user_data;
+ RuntimeConfig *runtime_config = (RuntimeConfig *)user_data;
if (strcmp (element_name, "runtime") == 0) {
runtime_config->runtime_count++;
gpointer user_data,
GError **error)
{
- RuntimeConfig *runtime_config = user_data;
+ RuntimeConfig *runtime_config = (RuntimeConfig *)user_data;
if (strcmp (element_name, "runtime") == 0)
runtime_config->runtime_count--;
else if (strcmp (element_name, "assemblyBinding") == 0)
static void
parse_error (GMarkupParseContext *context, GError *error, gpointer user_data)
{
- RuntimeConfig *state = user_data;
+ RuntimeConfig *state = (RuntimeConfig *)user_data;
const gchar *msg;
const gchar *filename;
if (len > 3 && text [0] == '\xef' && text [1] == (gchar) '\xbb' && text [2] == '\xbf')
offset = 3; /* Skip UTF-8 BOM */
- context = g_markup_parse_context_new (&mono_parser, 0, &runtime_config, NULL);
+ context = g_markup_parse_context_new (&mono_parser, (GMarkupParseFlags)0, &runtime_config, NULL);
if (g_markup_parse_context_parse (context, text + offset, len - offset, NULL))
g_markup_parse_context_end_parse (context, NULL);
g_markup_parse_context_free (context);
/* Need to skip internal assembly builders created by remoting */
mono_domain_assemblies_lock (domain);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- ass = tmp->data;
+ ass = (MonoAssembly *)tmp->data;
if (refonly != ass->ref_only)
continue;
if (ass->corlib_internal)
res = mono_array_new (domain, System_Reflection_Assembly, assemblies->len);
for (i = 0; i < assemblies->len; ++i) {
- ass = g_ptr_array_index (assemblies, i);
+ ass = (MonoAssembly *)g_ptr_array_index (assemblies, i);
mono_array_setref (res, i, mono_assembly_get_object (domain, ass));
}
if (domain->search_path)
g_strfreev (domain->search_path);
- tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
+ tmp = (gchar **)g_malloc ((npaths + 1) * sizeof (gchar *));
tmp [npaths] = NULL;
*tmp = mono_string_to_utf8_checked (setup->application_base, &error);
if (!u16_ini) {
return FALSE;
}
- handle = CreateFile (u16_ini, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
+ handle = (void **)CreateFile (u16_ini, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, CREATE_NEW, FileAttributes_Normal, NULL);
g_free (u16_ini);
if (handle == INVALID_HANDLE_VALUE) {
mono_domain_assemblies_lock (domain);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- ass = tmp->data;
+ ass = (MonoAssembly *)tmp->data;
/* Dynamic assemblies can't match here in MS.NET */
if (assembly_is_dynamic (ass) || refonly != ass->ref_only || !mono_assembly_names_equal (aname, &ass->aname))
continue;
GSList *list = image->reflection_info_unregister_classes;
while (list) {
- MonoClass *klass = list->data;
+ MonoClass *klass = (MonoClass *)list->data;
mono_class_free_ref_info (klass);
mono_domain_assemblies_lock (domain);
for (list = domain->domain_assemblies; list; list = list->next) {
- MonoAssembly *assembly = list->data;
+ MonoAssembly *assembly = (MonoAssembly *)list->data;
MonoImage *image = assembly->image;
int i;
* the collection there won't be any more remsets.
*/
for (i = 0; i < domain->class_vtable_array->len; ++i)
- zero_static_data (g_ptr_array_index (domain->class_vtable_array, i));
+ zero_static_data ((MonoVTable *)g_ptr_array_index (domain->class_vtable_array, i));
mono_gc_collect (0);
#endif
for (i = 0; i < domain->class_vtable_array->len; ++i)
- clear_cached_vtable (g_ptr_array_index (domain->class_vtable_array, i));
+ clear_cached_vtable ((MonoVTable *)g_ptr_array_index (domain->class_vtable_array, i));
deregister_reflection_info_roots (domain);
mono_assembly_cleanup_domain_bindings (domain->domain_id);
/* printf ("UNLOAD STARTING FOR %s (%p) IN THREAD 0x%x.\n", domain->friendly_name, domain, mono_native_thread_id_get ()); */
/* Atomically change our state to UNLOADING */
- prev_state = InterlockedCompareExchange ((gint32*)&domain->state,
- MONO_APPDOMAIN_UNLOADING_START,
- MONO_APPDOMAIN_CREATED);
+ prev_state = (MonoAppDomainState)InterlockedCompareExchange ((gint32*)&domain->state,
+ MONO_APPDOMAIN_UNLOADING_START,
+ MONO_APPDOMAIN_CREATED);
if (prev_state != MONO_APPDOMAIN_CREATED) {
switch (prev_state) {
case MONO_APPDOMAIN_UNLOADING_START:
gchar *res;
int i;
- res = g_malloc (len * 2 + 1);
+ res = (gchar *)g_malloc (len * 2 + 1);
for (i = 0; i < len; i++) {
res [i * 2] = allowed [token [i] >> 4];
res [i * 2 + 1] = allowed [token [i] & 0xF];
aname->revision = cols [MONO_ASSEMBLY_REV_NUMBER];
aname->hash_alg = cols [MONO_ASSEMBLY_HASH_ALG];
if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
- guchar* token = g_malloc (8);
+ guchar* token = (guchar *)g_malloc (8);
gchar* encoded;
const gchar* pkey;
int len;
* a non loaded reference using the ReflectionOnly api
*/
if (!reference)
- reference = REFERENCE_MISSING;
+ reference = (MonoAssembly *)REFERENCE_MISSING;
} else {
/* we first try without setting the basedir: this can eventually result in a ResolveAssembly
* event which is the MS .net compatible behaviour (the assemblyresolve_event3.cs test has been fixed
mono_assemblies_lock ();
if (reference == NULL) {
/* Flag as not found */
- reference = REFERENCE_MISSING;
+ reference = (MonoAssembly *)REFERENCE_MISSING;
}
if (!image->references [index]) {
/* Encode the size of the blob */
offset = 0;
if (keylen <= 127) {
- arr = g_malloc (keylen + 1);
+ arr = (gchar *)g_malloc (keylen + 1);
arr [offset++] = keylen;
} else {
- arr = g_malloc (keylen + 2);
+ arr = (gchar *)g_malloc (keylen + 2);
arr [offset++] = 0x80; /* 10bs */
arr [offset++] = keylen;
}
if (strstr (aname->name, ".dll")) {
len = strlen (aname->name) - 4;
- name = g_malloc (len);
+ name = (gchar *)g_malloc (len);
strncpy (name, aname->name, len);
} else
name = g_strdup (aname->name);
GSList *tmp;
for (tmp = loaded_assembly_bindings; tmp; tmp = tmp->next) {
- MonoAssemblyBindingInfo *info = tmp->data;
+ MonoAssemblyBindingInfo *info = (MonoAssemblyBindingInfo *)tmp->data;
if (assembly_binding_maps_name (info, aname))
return info;
}
return;
for (tmp = domain->assembly_bindings; tmp; tmp = tmp->next) {
- info_tmp = tmp->data;
+ info_tmp = (MonoAssemblyBindingInfo *)tmp->data;
if (strcmp (info->name, info_tmp->name) == 0 && info_versions_equal (info, info_tmp))
return;
}
- info_copy = mono_mempool_alloc0 (domain->mp, sizeof (MonoAssemblyBindingInfo));
+ info_copy = (MonoAssemblyBindingInfo *)mono_mempool_alloc0 (domain->mp, sizeof (MonoAssemblyBindingInfo));
memcpy (info_copy, info, sizeof (MonoAssemblyBindingInfo));
if (info->name)
info_copy->name = mono_mempool_strdup (domain->mp, info->name);
info = NULL;
for (list = domain->assembly_bindings; list; list = list->next) {
- info = list->data;
+ info = (MonoAssemblyBindingInfo *)list->data;
if (info && !strcmp (aname->name, info->name) && info_major_minor_in_range (info, aname))
break;
info = NULL;
info2 = get_per_domain_assembly_binding_info (domain, aname);
if (info2) {
- info = g_memdup (info2, sizeof (MonoAssemblyBindingInfo));
+ info = (MonoAssemblyBindingInfo *)g_memdup (info2, sizeof (MonoAssemblyBindingInfo));
info->name = g_strdup (info2->name);
info->culture = g_strdup (info2->culture);
info->domain_id = domain->domain_id;
if (strstr (aname->name, ".dll")) {
len = strlen (filename) - 4;
- name = g_malloc (len);
+ name = (gchar *)g_malloc (len);
strncpy (name, aname->name, len);
} else {
name = g_strdup (aname->name);
assembly->image = NULL;
for (tmp = assembly->friend_assembly_names; tmp; tmp = tmp->next) {
- MonoAssemblyName *fname = tmp->data;
+ MonoAssemblyName *fname = (MonoAssemblyName *)tmp->data;
mono_assembly_name_free (fname);
g_free (fname);
}
mono_os_mutex_destroy (&assembly_binding_mutex);
for (l = loaded_assembly_bindings; l; l = l->next) {
- MonoAssemblyBindingInfo *info = l->data;
+ MonoAssemblyBindingInfo *info = (MonoAssemblyBindingInfo *)l->data;
mono_assembly_binding_info_free (info);
g_free (info);
iter = &loaded_assembly_bindings;
while (*iter) {
GSList *l = *iter;
- MonoAssemblyBindingInfo *info = l->data;
+ MonoAssemblyBindingInfo *info = (MonoAssemblyBindingInfo *)l->data;
if (info->domain_id == domain_id) {
*iter = l->next;
g_assert (length < (1 << 16));
- s = g_malloc (length + 1);
+ s = (char *)g_malloc (length + 1);
g_assert (p + length <= limit);
memcpy (s, p, length);
content_len = decode_int (p, &p, p_end);
/* Read message body */
- body = g_malloc (content_len);
+ body = (guint8 *)g_malloc (content_len);
res = read (conn_fd, body, content_len);
p = body;
memset (&cb, 0, sizeof (cb));
cb.thread_register = boehm_thread_register;
cb.thread_unregister = boehm_thread_unregister;
- cb.mono_method_is_critical = (gpointer)mono_runtime_is_critical_method;
+ cb.mono_method_is_critical = (gboolean (*)(void *))mono_runtime_is_critical_method;
mono_threads_init (&cb, sizeof (MonoThreadInfo));
mono_os_mutex_init (&mono_gc_lock);
gboolean
mono_object_is_alive (MonoObject* o)
{
- return GC_is_marked ((gpointer)o);
+ return GC_is_marked ((ptr_t)o);
}
int
static gpointer
reveal_link (gpointer link_addr)
{
- void **link_a = link_addr;
+ void **link_a = (void **)link_addr;
return REVEAL_POINTER (*link_a);
}
static MonoObject *
mono_gc_weak_link_get (void **link_addr)
{
- MonoObject *obj = GC_call_with_alloc_lock (reveal_link, link_addr);
+ MonoObject *obj = (MonoObject *)GC_call_with_alloc_lock (reveal_link, link_addr);
if (obj == (MonoObject *) -1)
return NULL;
return obj;
MonoObject *obj;
if (!vtable->klass->has_references) {
- obj = GC_MALLOC_ATOMIC (size);
+ obj = (MonoObject *)GC_MALLOC_ATOMIC (size);
obj->vtable = vtable;
obj->synchronisation = NULL;
memset ((char *) obj + sizeof (MonoObject), 0, size - sizeof (MonoObject));
} else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
- obj = GC_GCJ_MALLOC (size, vtable);
+ obj = (MonoObject *)GC_GCJ_MALLOC (size, vtable);
} else {
- obj = GC_MALLOC (size);
+ obj = (MonoObject *)GC_MALLOC (size);
obj->vtable = vtable;
}
MonoArray *obj;
if (!vtable->klass->has_references) {
- obj = GC_MALLOC_ATOMIC (size);
+ obj = (MonoArray *)GC_MALLOC_ATOMIC (size);
obj->obj.vtable = vtable;
obj->obj.synchronisation = NULL;
memset ((char *) obj + sizeof (MonoObject), 0, size - sizeof (MonoObject));
} else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
- obj = GC_GCJ_MALLOC (size, vtable);
+ obj = (MonoArray *)GC_GCJ_MALLOC (size, vtable);
} else {
- obj = GC_MALLOC (size);
+ obj = (MonoArray *)GC_MALLOC (size);
obj->obj.vtable = vtable;
}
MonoArray *obj;
if (!vtable->klass->has_references) {
- obj = GC_MALLOC_ATOMIC (size);
+ obj = (MonoArray *)GC_MALLOC_ATOMIC (size);
obj->obj.vtable = vtable;
obj->obj.synchronisation = NULL;
memset ((char *) obj + sizeof (MonoObject), 0, size - sizeof (MonoObject));
} else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
- obj = GC_GCJ_MALLOC (size, vtable);
+ obj = (MonoArray *)GC_GCJ_MALLOC (size, vtable);
} else {
- obj = GC_MALLOC (size);
+ obj = (MonoArray *)GC_MALLOC (size);
obj->obj.vtable = vtable;
}
void *
mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
{
- MonoString *obj = GC_MALLOC_ATOMIC (size);
+ MonoString *obj = (MonoString *)GC_MALLOC_ATOMIC (size);
obj->object.vtable = vtable;
obj->object.synchronisation = NULL;
void
mono_gc_wbarrier_generic_store_atomic (gpointer ptr, MonoObject *value)
{
- InterlockedWritePointer (ptr, value);
+ InterlockedWritePointer ((volatile gpointer *)ptr, value);
}
void
g_assert (GC_base (obj) == (char*)obj - offset);
#endif
- GC_REGISTER_FINALIZER_NO_ORDER ((char*)obj - offset, user_data, GUINT_TO_POINTER (offset), NULL, NULL);
+ GC_REGISTER_FINALIZER_NO_ORDER ((char*)obj - offset, (GC_finalization_proc)user_data, GUINT_TO_POINTER (offset), NULL, NULL);
}
#ifndef HOST_WIN32
test_toggleref_callback (MonoObject *obj)
{
static MonoClassField *mono_toggleref_test_field;
- int status = MONO_TOGGLE_REF_DROP;
+ MonoToggleRefStatus status = MONO_TOGGLE_REF_DROP;
if (!mono_toggleref_test_field) {
mono_toggleref_test_field = mono_class_get_field_from_name (mono_object_get_class (obj), "__test");
{
handles->size = 32;
if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
- handles->entries = g_malloc0 (sizeof (*handles->entries) * handles->size);
- handles->domain_ids = g_malloc0 (sizeof (*handles->domain_ids) * handles->size);
+ handles->entries = (void **)g_malloc0 (sizeof (*handles->entries) * handles->size);
+ handles->domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * handles->size);
} else {
- handles->entries = mono_gc_alloc_fixed (sizeof (*handles->entries) * handles->size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
+ handles->entries = (void **)mono_gc_alloc_fixed (sizeof (*handles->entries) * handles->size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
}
- handles->bitmap = g_malloc0 (handles->size / CHAR_BIT);
+ handles->bitmap = (guint32 *)g_malloc0 (handles->size / CHAR_BIT);
}
static gint
guint32 new_size = handles->size * 2; /* always double: we memset to 0 based on this below */
/* resize and copy the bitmap */
- new_bitmap = g_malloc0 (new_size / CHAR_BIT);
+ new_bitmap = (guint32 *)g_malloc0 (new_size / CHAR_BIT);
memcpy (new_bitmap, handles->bitmap, handles->size / CHAR_BIT);
g_free (handles->bitmap);
handles->bitmap = new_bitmap;
gpointer *entries;
guint16 *domain_ids;
gint i;
- domain_ids = g_malloc0 (sizeof (*handles->domain_ids) * new_size);
- entries = g_malloc0 (sizeof (*handles->entries) * new_size);
+ domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * new_size);
+ entries = (void **)g_malloc0 (sizeof (*handles->entries) * new_size);
memcpy (domain_ids, handles->domain_ids, sizeof (*handles->domain_ids) * handles->size);
for (i = 0; i < handles->size; ++i) {
MonoObject *obj = mono_gc_weak_link_get (&(handles->entries [i]));
handles->domain_ids = domain_ids;
} else {
gpointer *entries;
- entries = mono_gc_alloc_fixed (sizeof (*handles->entries) * new_size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
+ entries = (void **)mono_gc_alloc_fixed (sizeof (*handles->entries) * new_size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
mono_gc_memmove_aligned (entries, handles->entries, sizeof (*handles->entries) * handles->size);
mono_gc_free_fixed (handles->entries);
handles->entries = entries;
if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
obj = mono_gc_weak_link_get (&handles->entries [slot]);
} else {
- obj = handles->entries [slot];
+ obj = (MonoObject *)handles->entries [slot];
}
} else {
/* print a warning? */
lock_handles (handles);
if (slot < handles->size && slot_occupied (handles, slot)) {
if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
- old_obj = handles->entries [slot];
+ old_obj = (MonoObject *)handles->entries [slot];
if (handles->entries [slot])
mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
if (obj)
result = domain->domain_id == handles->domain_ids [slot];
} else {
MonoObject *obj;
- obj = handles->entries [slot];
+ obj = (MonoObject *)handles->entries [slot];
if (obj == NULL)
result = TRUE;
else
if (enclosing->nested_classes_inited && enclosing->ext) {
/* Micro-optimization: don't scan the metadata tables if enclosing is already inited */
for (tmp = enclosing->ext->nested_classes; tmp; tmp = tmp->next) {
- res = tmp->data;
+ res = (MonoClass *)tmp->data;
if (strcmp (res->name, name) == 0)
return res;
}
mono_dup_array_type (MonoImage *image, MonoArrayType *a)
{
if (image) {
- a = mono_image_memdup (image, a, sizeof (MonoArrayType));
+ a = (MonoArrayType *)mono_image_memdup (image, a, sizeof (MonoArrayType));
if (a->sizes)
- a->sizes = mono_image_memdup (image, a->sizes, a->numsizes * sizeof (int));
+ a->sizes = (int *)mono_image_memdup (image, a->sizes, a->numsizes * sizeof (int));
if (a->lobounds)
- a->lobounds = mono_image_memdup (image, a->lobounds, a->numlobounds * sizeof (int));
+ a->lobounds = (int *)mono_image_memdup (image, a->lobounds, a->numlobounds * sizeof (int));
} else {
- a = g_memdup (a, sizeof (MonoArrayType));
+ a = (MonoArrayType *)g_memdup (a, sizeof (MonoArrayType));
if (a->sizes)
- a->sizes = g_memdup (a->sizes, a->numsizes * sizeof (int));
+ a->sizes = (int *)g_memdup (a->sizes, a->numsizes * sizeof (int));
if (a->lobounds)
- a->lobounds = g_memdup (a->lobounds, a->numlobounds * sizeof (int));
+ a->lobounds = (int *)g_memdup (a->lobounds, a->numlobounds * sizeof (int));
}
return a;
}
// check cache
mono_image_set_lock (set);
- cached = g_hash_table_lookup (set->gmethod_cache, iresult);
+ cached = (MonoMethodInflated *)g_hash_table_lookup (set->gmethod_cache, iresult);
mono_image_set_unlock (set);
if (cached) {
// check cache
mono_image_set_lock (set);
- cached = g_hash_table_lookup (set->gmethod_cache, iresult);
+ cached = (MonoMethodInflated *)g_hash_table_lookup (set->gmethod_cache, iresult);
if (!cached) {
g_hash_table_insert (set->gmethod_cache, iresult, iresult);
iresult->owner = set;
if (!method->is_generic)
return NULL;
- container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
+ container = (MonoGenericContainer *)mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
g_assert (container);
return container;
klass->field.count = gtd->field.count;
}
- klass->fields = mono_class_alloc0 (klass, sizeof (MonoClassField) * top);
+ klass->fields = (MonoClassField *)mono_class_alloc0 (klass, sizeof (MonoClassField) * top);
/*
* Fetch all the field information.
/* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
count = gklass->method.count;
- methods = mono_class_alloc0 (klass, sizeof (MonoMethod*) * (count + 1));
+ methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * (count + 1));
for (i = 0; i < count; i++) {
methods [i] = mono_class_inflate_generic_method_full_checked (
count += klass->interface_count * count_generic;
}
- methods = mono_class_alloc0 (klass, sizeof (MonoMethod*) * count);
+ methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * count);
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = &mono_defaults.void_class->byval_arg;
MonoError error;
count = klass->method.count;
- methods = mono_class_alloc (klass, sizeof (MonoMethod*) * count);
+ methods = (MonoMethod **)mono_class_alloc (klass, sizeof (MonoMethod*) * count);
for (i = 0; i < count; ++i) {
int idx = mono_metadata_translate_token_index (klass->image, MONO_TABLE_METHOD, klass->method.first + i + 1);
methods [i] = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | idx, klass, NULL, &error);
return;
}
- properties = mono_class_alloc0 (klass, sizeof (MonoProperty) * count);
+ properties = (MonoProperty *)mono_class_alloc0 (klass, sizeof (MonoProperty) * count);
for (i = first; i < last; ++i) {
mono_metadata_decode_table_row (klass->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
properties [i - first].parent = klass;
}
}
- events = mono_class_alloc0 (klass, sizeof (MonoEvent) * count);
+ events = (MonoEvent *)mono_class_alloc0 (klass, sizeof (MonoEvent) * count);
for (i = first; i < last; ++i) {
MonoEvent *event = &events [i - first];
} else {
while (event->other [n])
n++;
- event->other = g_realloc (event->other, (n + 2) * sizeof (MonoMethod*));
+ event->other = (MonoMethod **)g_realloc (event->other, (n + 2) * sizeof (MonoMethod*));
}
event->other [n] = method;
/* NULL terminated */
static int
compare_interface_ids (const void *p_key, const void *p_element) {
- const MonoClass *key = p_key;
- const MonoClass *element = *(MonoClass**) p_element;
+ const MonoClass *key = (const MonoClass *)p_key;
+ const MonoClass *element = *(const MonoClass **)p_element;
return (key->interface_id - element->interface_id);
}
/*FIXME verify all callers if they should switch to mono_class_interface_offset_with_variance*/
int
mono_class_interface_offset (MonoClass *klass, MonoClass *itf) {
- MonoClass **result = mono_binary_search (
+ MonoClass **result = (MonoClass **)mono_binary_search (
itf,
klass->interfaces_packed,
klass->interface_offsets_count,
mono_error_cleanup (&error);
} else if (ifaces) {
for (i = 0; i < ifaces->len; i++) {
- MonoClass *ic = g_ptr_array_index (ifaces, i);
+ MonoClass *ic = (MonoClass *)g_ptr_array_index (ifaces, i);
printf (" [UIID %d] interface %s\n", ic->interface_id, ic->name);
printf (" [%03d][UUID %03d][SLOT %03d][SIZE %03d] interface %s.%s\n", i,
ic->interface_id,
++real_count;
}
- interfaces = g_malloc0 (sizeof (MonoClass*) * real_count);
+ interfaces = (MonoClass **)g_malloc0 (sizeof (MonoClass*) * real_count);
interfaces [0] = valuetype_types [0];
if (valuetype_types [1])
interfaces [nifaces] = valuetype_types [1];
if (valuetype_types [1])
++real_count;
}
- interfaces = g_malloc0 (sizeof (MonoClass*) * real_count);
+ interfaces = (MonoClass **)g_malloc0 (sizeof (MonoClass*) * real_count);
if (MONO_CLASS_IS_INTERFACE (eclass)) {
interfaces [0] = mono_defaults.object_class;
j = nifaces;
if (ifaces) {
num_ifaces += ifaces->len;
for (i = 0; i < ifaces->len; ++i) {
- ic = g_ptr_array_index (ifaces, i);
+ ic = (MonoClass *)g_ptr_array_index (ifaces, i);
if (max_iid < ic->interface_id)
max_iid = ic->interface_id;
}
}
klass->max_interface_id = max_iid;
/* compute vtable offset for interfaces */
- interfaces_full = g_malloc0 (sizeof (MonoClass*) * num_ifaces);
- interface_offsets_full = g_malloc (sizeof (int) * num_ifaces);
+ interfaces_full = (MonoClass **)g_malloc0 (sizeof (MonoClass*) * num_ifaces);
+ interface_offsets_full = (int *)g_malloc (sizeof (int) * num_ifaces);
for (i = 0; i < num_ifaces; i++) {
interface_offsets_full [i] = -1;
if (ifaces) {
for (i = 0; i < ifaces->len; ++i) {
int io;
- ic = g_ptr_array_index (ifaces, i);
+ ic = (MonoClass *)g_ptr_array_index (ifaces, i);
/*Force the sharing of interface offsets between parent and subtypes.*/
io = mono_class_interface_offset (k, ic);
if (ifaces) {
for (i = 0; i < ifaces->len; ++i) {
int count;
- ic = g_ptr_array_index (ifaces, i);
+ ic = (MonoClass *)g_ptr_array_index (ifaces, i);
if (set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, cur_slot, FALSE))
continue;
count = count_virtual_methods (ic);
uint8_t *bitmap;
int bsize;
klass->interface_offsets_count = interface_offsets_count;
- klass->interfaces_packed = mono_class_alloc (klass, sizeof (MonoClass*) * interface_offsets_count);
- klass->interface_offsets_packed = mono_class_alloc (klass, sizeof (guint16) * interface_offsets_count);
+ klass->interfaces_packed = (MonoClass **)mono_class_alloc (klass, sizeof (MonoClass*) * interface_offsets_count);
+ klass->interface_offsets_packed = (guint16 *)mono_class_alloc (klass, sizeof (guint16) * interface_offsets_count);
bsize = (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0);
#ifdef COMPRESSED_INTERFACE_BITMAP
bitmap = g_malloc0 (bsize);
#else
- bitmap = mono_class_alloc0 (klass, bsize);
+ bitmap = (uint8_t *)mono_class_alloc0 (klass, bsize);
#endif
for (i = 0; i < interface_offsets_count; i++) {
int id = interfaces_full [i]->interface_id;
return;
} else if (ifaces) {
for (i = 0; i < ifaces->len; i++) {
- MonoClass *ic = g_ptr_array_index (ifaces, i);
+ MonoClass *ic = (MonoClass *)g_ptr_array_index (ifaces, i);
max_vtsize += ic->method.count;
}
g_ptr_array_free (ifaces, TRUE);
++cur_slot;
}
- vtable = alloca (sizeof (gpointer) * max_vtsize);
+ vtable = (MonoMethod **)alloca (sizeof (gpointer) * max_vtsize);
memset (vtable, 0, sizeof (gpointer) * max_vtsize);
/* printf ("METAINIT %s.%s\n", klass->name_space, klass->name); */
return;
}
- tmp = mono_class_alloc0 (klass, sizeof (gpointer) * gklass->vtable_size);
+ tmp = (MonoMethod **)mono_class_alloc0 (klass, sizeof (gpointer) * gklass->vtable_size);
klass->vtable_size = gklass->vtable_size;
for (i = 0; i < gklass->vtable_size; ++i)
if (gklass->vtable [i]) {
for (im_index = 0; im_index < ic->method.count; im_index++) {
MonoMethod *im = ic->methods [im_index];
int im_slot = ic_offset + im->slot;
- MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL;
+ MonoMethod *override_im = (override_map != NULL) ? (MonoMethod *)g_hash_table_lookup (override_map, im) : NULL;
if (im->flags & METHOD_ATTRIBUTE_STATIC)
continue;
// First look for a suitable method among the class methods
for (l = virt_methods; l; l = l->next) {
- cm = l->data;
+ cm = (MonoMethod *)l->data;
TRACE_INTERFACE_VTABLE (printf (" For slot %d ('%s'.'%s':'%s'), trying method '%s'.'%s':'%s'... [EXPLICIT IMPLEMENTATION = %d][SLOT IS NULL = %d]", im_slot, ic->name_space, ic->name, im->name, cm->klass->name_space, cm->klass->name, cm->name, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL)));
if (check_interface_method_override (klass, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL))) {
TRACE_INTERFACE_VTABLE (printf ("[check ok]: ASSIGNING"));
TRACE_INTERFACE_VTABLE (print_vtable_full (klass, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
for (l = virt_methods; l; l = l->next) {
- cm = l->data;
+ cm = (MonoMethod *)l->data;
/*
* If the method is REUSE_SLOT, we must check in the
* base class for a method to override.
if (vtable [i]) {
TRACE_INTERFACE_VTABLE (printf ("checking slot %d method %s[%p] for overrides\n", i, mono_method_full_name (vtable [i], 1), vtable [i]));
- cm = g_hash_table_lookup (override_map, vtable [i]);
+ cm = (MonoMethod *)g_hash_table_lookup (override_map, vtable [i]);
if (cm)
vtable [i] = cm;
}
mono_memory_barrier ();
klass->vtable = klass->parent->vtable;
} else {
- MonoMethod **tmp = mono_class_alloc0 (klass, sizeof (gpointer) * klass->vtable_size);
+ MonoMethod **tmp = (MonoMethod **)mono_class_alloc0 (klass, sizeof (gpointer) * klass->vtable_size);
memcpy (tmp, vtable, sizeof (gpointer) * klass->vtable_size);
mono_memory_barrier ();
klass->vtable = tmp;
}
}
list = g_list_reverse (list);
- generic_array_method_info = mono_image_alloc (mono_defaults.corlib, sizeof (GenericArrayMethodInfo) * count_generic);
+ generic_array_method_info = (GenericArrayMethodInfo *)mono_image_alloc (mono_defaults.corlib, sizeof (GenericArrayMethodInfo) * count_generic);
i = 0;
for (tmp = list; tmp; tmp = tmp->next) {
const char *mname, *iname;
gchar *name;
- MonoMethod *m = tmp->data;
+ MonoMethod *m = (MonoMethod *)tmp->data;
const char *ireadonlylist_prefix = "InternalArray__IReadOnlyList_";
const char *ireadonlycollection_prefix = "InternalArray__IReadOnlyCollection_";
g_assert_not_reached ();
}
- name = mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1);
+ name = (gchar *)mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1);
strcpy (name, iname);
strcpy (name + strlen (iname), mname);
generic_array_method_info [i].name = name;
{
int null_length = strlen ("(null)");
int len = (s1 ? strlen (s1) : null_length) + (s2 ? strlen (s2) : null_length) + 2;
- char *s = mono_image_alloc (image, len);
+ char *s = (char *)mono_image_alloc (image, len);
int result;
result = g_snprintf (s, len, "%s%c%s", s1 ? s1 : "(null)", '\0', s2 ? s2 : "(null)");
klass->valuetype = 0;
klass->enumtype = 0;
} else if (!strcmp (name, "Object")) {
- klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_OBJECT;
+ klass->byval_arg.type = MONO_TYPE_OBJECT;
+ klass->this_arg.type = MONO_TYPE_OBJECT;
} else if (!strcmp (name, "String")) {
- klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_STRING;
+ klass->byval_arg.type = MONO_TYPE_STRING;
+ klass->this_arg.type = MONO_TYPE_STRING;
} else if (!strcmp (name, "TypedReference")) {
- klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_TYPEDBYREF;
+ klass->byval_arg.type = MONO_TYPE_TYPEDBYREF;
+ klass->this_arg.type = MONO_TYPE_TYPEDBYREF;
}
}
break;
}
}
- klass->this_arg.type = klass->byval_arg.type = t;
+ klass->byval_arg.type = (MonoTypeEnum)t;
+ klass->this_arg.type = (MonoTypeEnum)t;
}
if (MONO_CLASS_IS_INTERFACE (klass))
int ms;
MonoClass **supertypes;
- mono_atomic_load_acquire (supertypes, void*, &klass->supertypes);
+ mono_atomic_load_acquire (supertypes, MonoClass **, &klass->supertypes);
if (supertypes)
return;
klass->idepth = 1;
ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, klass->idepth);
- supertypes = mono_class_alloc0 (klass, sizeof (MonoClass *) * ms);
+ supertypes = (MonoClass **)mono_class_alloc0 (klass, sizeof (MonoClass *) * ms);
if (klass->parent) {
CHECKED_METADATA_WRITE_PTR ( supertypes [klass->idepth - 1] , klass );
mono_loader_lock ();
- if ((klass = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
+ if ((klass = (MonoClass *)mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
mono_loader_unlock ();
mono_loader_assert_no_error ();
return klass;
name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
- klass = mono_image_alloc0 (image, sizeof (MonoClass));
+ klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass));
klass->name = name;
klass->name_space = nspace;
return gclass->cached_class;
}
- klass = mono_image_set_alloc0 (gclass->owner, sizeof (MonoClass));
+ klass = (MonoClass *)mono_image_set_alloc0 (gclass->owner, sizeof (MonoClass));
gklass = gclass->container_class;
klass->is_inflated = 1;
klass->generic_class = gclass;
- klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_GENERICINST;
+ klass->byval_arg.type = MONO_TYPE_GENERICINST;
+ klass->this_arg.type = klass->byval_arg.type;
klass->this_arg.data.generic_class = klass->byval_arg.data.generic_class = gclass;
klass->this_arg.byref = TRUE;
klass->enumtype = gklass->enumtype;
char *
make_generic_name_string (MonoImage *image, int num)
{
- char *name = mono_image_alloc0 (image, INT_STRING_SIZE);
+ char *name = (char *)mono_image_alloc0 (image, INT_STRING_SIZE);
g_snprintf (name, INT_STRING_SIZE, "%d", num);
return name;
}
gboolean is_mvar = container->is_method;
gboolean is_anonymous = container->is_anonymous;
- klass = mono_image_alloc0 (image, sizeof (MonoClass));
+ klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass));
classes_size += sizeof (MonoClass);
if (pinfo) {
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name , pinfo->name );
} else {
int n = mono_generic_param_num (param);
-
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->name , make_generic_name_string (image, n) );
}
if (count - pos > 0) {
klass->interface_count = count - pos;
- CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->interfaces , mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos)) );
+ CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->interfaces , (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos)) );
klass->interfaces_inited = TRUE;
for (i = pos; i < count; i++)
CHECKED_METADATA_WRITE_PTR ( klass->interfaces [i - pos] , pinfo->constraints [i] );
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->element_class , klass );
klass->flags = TYPE_ATTRIBUTE_PUBLIC;
- klass->this_arg.type = klass->byval_arg.type = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR;
+ klass->byval_arg.type = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR;
+ klass->this_arg.type = klass->byval_arg.type;
CHECKED_METADATA_WRITE_PTR ( klass->this_arg.data.generic_param , param );
CHECKED_METADATA_WRITE_PTR ( klass->byval_arg.data.generic_param , param );
klass->this_arg.byref = TRUE;
if (ht) {
if (take_lock)
mono_image_lock (image);
- klass = g_hash_table_lookup (ht, param);
+ klass = (MonoClass *)g_hash_table_lookup (ht, param);
if (take_lock)
mono_image_unlock (image);
}
if (ht) {
if (take_lock)
mono_image_lock (image);
- klass = g_hash_table_lookup (ht, GINT_TO_POINTER (n));
+ klass = (MonoClass *)g_hash_table_lookup (ht, GINT_TO_POINTER (n));
if (take_lock)
mono_image_unlock (image);
}
if (is_mvar) {
/* Requires locking to avoid droping an already published class */
if (!image->mvar_cache_fast)
- image->mvar_cache_fast = mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE);
+ image->mvar_cache_fast = (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE);
image->mvar_cache_fast [n] = klass;
} else {
if (!image->var_cache_fast)
- image->var_cache_fast = mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE);
+ image->var_cache_fast = (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE);
image->var_cache_fast [n] = klass;
}
} else {
mono_image_lock (image);
if (image->ptr_cache) {
- if ((result = g_hash_table_lookup (image->ptr_cache, el_class))) {
+ if ((result = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) {
mono_image_unlock (image);
return result;
}
}
mono_image_unlock (image);
- result = mono_image_alloc0 (image, sizeof (MonoClass));
+ result = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass));
classes_size += sizeof (MonoClass);
result->cast_class = result->element_class = el_class;
result->blittable = TRUE;
- result->this_arg.type = result->byval_arg.type = MONO_TYPE_PTR;
+ result->byval_arg.type = MONO_TYPE_PTR;
+ result->this_arg.type = result->byval_arg.type;
result->this_arg.data.type = result->byval_arg.data.type = &result->element_class->byval_arg;
result->this_arg.byref = TRUE;
mono_image_lock (image);
if (image->ptr_cache) {
MonoClass *result2;
- if ((result2 = g_hash_table_lookup (image->ptr_cache, el_class))) {
+ if ((result2 = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) {
mono_image_unlock (image);
mono_profiler_class_loaded (result, MONO_PROFILE_FAILED);
return result2;
if (!ptr_hash)
ptr_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- if ((result = g_hash_table_lookup (ptr_hash, sig))) {
+ if ((result = (MonoClass *)g_hash_table_lookup (ptr_hash, sig))) {
mono_loader_unlock ();
return result;
}
result->cast_class = result->element_class = result;
result->blittable = TRUE;
- result->this_arg.type = result->byval_arg.type = MONO_TYPE_FNPTR;
+ result->byval_arg.type = MONO_TYPE_FNPTR;
+ result->this_arg.type = result->byval_arg.type;
result->this_arg.data.method = result->byval_arg.data.method = sig;
result->this_arg.byref = TRUE;
result->blittable = TRUE;
mono_os_mutex_lock (&image->szarray_cache_lock);
if (!image->szarray_cache)
image->szarray_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
- klass = g_hash_table_lookup (image->szarray_cache, eclass);
+ klass = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
if (klass)
return klass;
if (!image->array_cache)
image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
- if ((rootlist = list = g_hash_table_lookup (image->array_cache, eclass))) {
+ if ((rootlist = list = (GSList *)g_hash_table_lookup (image->array_cache, eclass))) {
for (; list; list = list->next) {
- klass = list->data;
+ klass = (MonoClass *)list->data;
if ((klass->rank == rank) && (klass->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
mono_loader_unlock ();
return klass;
mono_class_init (parent);
}
- klass = mono_image_alloc0 (image, sizeof (MonoClass));
+ klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass));
klass->image = image;
klass->name_space = eclass->name_space;
nsize = strlen (eclass->name);
- name = g_malloc (nsize + 2 + rank + 1);
+ name = (char *)g_malloc (nsize + 2 + rank + 1);
memcpy (name, eclass->name, nsize);
name [nsize] = '[';
if (rank > 1)
klass->element_class = eclass;
if ((rank > 1) || bounded) {
- MonoArrayType *at = mono_image_alloc0 (image, sizeof (MonoArrayType));
+ MonoArrayType *at = (MonoArrayType *)mono_image_alloc0 (image, sizeof (MonoArrayType));
klass->byval_arg.type = MONO_TYPE_ARRAY;
klass->byval_arg.data.array = at;
at->eklass = eclass;
MonoClass *prev_class;
mono_os_mutex_lock (&image->szarray_cache_lock);
- prev_class = g_hash_table_lookup (image->szarray_cache, eclass);
+ prev_class = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass);
if (prev_class)
/* Someone got in before us */
klass = prev_class;
mono_class_alloc_ext (klass);
- def_values = mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count);
+ def_values = (MonoFieldDefaultValue *)mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count);
mono_image_lock (klass->image);
mono_memory_barrier ();
g_assert (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA));
mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
- klass->ext->field_def_values [field_index].def_type = constant_cols [MONO_CONSTANT_TYPE];
- klass->ext->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
+ klass->ext->field_def_values [field_index].def_type = (MonoTypeEnum)constant_cols [MONO_CONSTANT_TYPE];
+ klass->ext->field_def_values [field_index].data = (const char *)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
}
*def_type = klass->ext->field_def_values [field_index].def_type;
return NULL;
mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
- *def_type = constant_cols [MONO_CONSTANT_TYPE];
- return (gpointer)mono_metadata_blob_heap (klass->image, constant_cols [MONO_CONSTANT_VALUE]);
+ *def_type = (MonoTypeEnum)constant_cols [MONO_CONSTANT_TYPE];
+ return (const char *)mono_metadata_blob_heap (klass->image, constant_cols [MONO_CONSTANT_VALUE]);
}
guint32
mono_error_set_bad_image (error, image,"Bad token table for dynamic image: %x", table);
return NULL;
}
- klass = mono_lookup_dynamic_token (image, type_token, NULL); /*FIXME proper error handling*/
+ klass = (MonoClass *)mono_lookup_dynamic_token (image, type_token, NULL); /*FIXME proper error handling*/
goto done;
}
//FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
if (image_is_dynamic (image))
- return mono_class_get_type (mono_lookup_dynamic_token (image, type_token, context));
+ return mono_class_get_type ((MonoClass *)mono_lookup_dynamic_token (image, type_token, context));
if ((type_token & 0xff000000) != MONO_TOKEN_TYPE_SPEC) {
MonoClass *klass = mono_class_get_checked (image, type_token, error);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
nspace_index = cols [MONO_TYPEDEF_NAMESPACE];
- nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
+ nspace_table = (GHashTable *)g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
if (!nspace_table) {
nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (the_name_cache, (char*)nspace, nspace_table);
nspace = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAMESPACE]);
nspace_index = cols [MONO_EXP_TYPE_NAMESPACE];
- nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
+ nspace_table = (GHashTable *)g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
if (!nspace_table) {
nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (the_name_cache, (char*)nspace, nspace_table);
mono_image_lock (image);
name_cache = image->name_cache;
- if (!(nspace_table = g_hash_table_lookup (name_cache, nspace))) {
+ if (!(nspace_table = (GHashTable *)g_hash_table_lookup (name_cache, nspace))) {
nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (name_cache, (char *)nspace, (char *)nspace_table);
}
mono_image_init_name_cache (image);
mono_image_lock (image);
- nspace_table = g_hash_table_lookup (image->name_cache, name_space);
+ nspace_table = (GHashTable *)g_hash_table_lookup (image->name_cache, name_space);
if (nspace_table)
token = GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table, name));
/*A TypeBuilder can have more interfaces on tb->interfaces than on candidate->interfaces*/
if (image_is_dynamic (candidate->image) && !candidate->wastypebuilder) {
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (candidate);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (candidate);
int j;
if (tb && tb->interfaces) {
for (j = mono_array_length (tb->interfaces) - 1; j >= 0; --j) {
return NULL;
/* start from the first */
if (klass->field.count) {
- return *iter = &klass->fields [0];
+ *iter = &klass->fields [0];
+ return &klass->fields [0];
} else {
/* no fields */
return NULL;
}
}
- field = *iter;
+ field = (MonoClassField *)*iter;
field++;
if (field < &klass->fields [klass->field.count]) {
- return *iter = field;
+ *iter = field;
+ return field;
}
return NULL;
}
return NULL;
}
}
- method = *iter;
+ method = (MonoMethod **)*iter;
method++;
if (method < &klass->methods [klass->method.count]) {
*iter = method;
/* start from the first */
method = &klass->methods [0];
} else {
- method = *iter;
+ method = (MonoMethod **)*iter;
method++;
}
while (method < &klass->methods [klass->method.count]) {
mono_class_setup_properties (klass);
/* start from the first */
if (klass->ext->property.count) {
- return *iter = &klass->ext->properties [0];
+ *iter = &klass->ext->properties [0];
+ return (MonoProperty *)*iter;
} else {
/* no fields */
return NULL;
}
}
- property = *iter;
+ property = (MonoProperty *)*iter;
property++;
if (property < &klass->ext->properties [klass->ext->property.count]) {
- return *iter = property;
+ *iter = property;
+ return (MonoProperty *)*iter;
}
return NULL;
}
mono_class_setup_events (klass);
/* start from the first */
if (klass->ext->event.count) {
- return *iter = &klass->ext->events [0];
+ *iter = &klass->ext->events [0];
+ return (MonoEvent *)*iter;
} else {
/* no fields */
return NULL;
}
}
- event = *iter;
+ event = (MonoEvent *)*iter;
event++;
if (event < &klass->ext->events [klass->ext->event.count]) {
- return *iter = event;
+ *iter = event;
+ return (MonoEvent *)*iter;
}
return NULL;
}
return NULL;
}
}
- iface = *iter;
+ iface = (MonoClass **)*iter;
iface++;
if (iface < &klass->interfaces [klass->interface_count]) {
*iter = iface;
/* start from the first */
if (klass->ext && klass->ext->nested_classes) {
*iter = klass->ext->nested_classes;
- return klass->ext->nested_classes->data;
+ return (MonoClass *)klass->ext->nested_classes->data;
} else {
/* no nested types */
return NULL;
}
}
- item = *iter;
+ item = (GList *)*iter;
item = item->next;
if (item) {
*iter = item;
- return item->data;
+ return (MonoClass *)item->data;
}
return NULL;
}
if (!klass->ext || !klass->ext->field_def_values) {
mono_class_alloc_ext (klass);
- field_def_values = mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count);
+ field_def_values = (MonoFieldDefaultValue *)mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count);
mono_image_lock (klass->image);
if (!klass->ext->field_def_values)
return ex;
}
case MONO_EXCEPTION_MISSING_METHOD: {
- char *class_name = exception_data;
+ char *class_name = (char *)exception_data;
char *assembly_name = class_name + strlen (class_name) + 1;
return mono_get_exception_missing_method (class_name, assembly_name);
}
case MONO_EXCEPTION_MISSING_FIELD: {
- char *class_name = exception_data;
+ char *class_name = (char *)exception_data;
char *member_name = class_name + strlen (class_name) + 1;
return mono_get_exception_missing_field (class_name, member_name);
}
case MONO_EXCEPTION_FILE_NOT_FOUND: {
- char *msg_format = exception_data;
+ char *msg_format = (char *)exception_data;
char *assembly_name = msg_format + strlen (msg_format) + 1;
char *msg = g_strdup_printf (msg_format, assembly_name);
MonoException *ex;
return ex;
}
case MONO_EXCEPTION_BAD_IMAGE: {
- return mono_get_exception_bad_image_format (exception_data);
+ return mono_get_exception_bad_image_format ((const char *)exception_data);
}
default: {
MonoLoaderError *error;
mono_assembly_load_friends (accessed);
for (tmp = accessed->friend_assembly_names; tmp; tmp = tmp->next) {
- MonoAssemblyName *friend = tmp->data;
+ MonoAssemblyName *friend_ = (MonoAssemblyName *)tmp->data;
/* Be conservative with checks */
- if (!friend->name)
+ if (!friend_->name)
continue;
- if (strcmp (accessing->aname.name, friend->name))
+ if (strcmp (accessing->aname.name, friend_->name))
continue;
- if (friend->public_key_token [0]) {
+ if (friend_->public_key_token [0]) {
if (!accessing->aname.public_key_token [0])
continue;
- if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token))
+ if (!mono_public_tokens_are_equal (friend_->public_key_token, accessing->aname.public_key_token))
continue;
}
return TRUE;
if (klass->ext)
return;
- ext = mono_class_alloc0 (klass, sizeof (MonoClassExt));
+ ext = (MonoClassExt *)mono_class_alloc0 (klass, sizeof (MonoClassExt));
mono_image_lock (klass->image);
mono_memory_barrier ();
if (!klass->ext)
/* generic IList, ICollection, IEnumerable */
interface_count = mono_defaults.generic_ireadonlylist_class ? 2 : 1;
- interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * interface_count);
+ interfaces = (MonoClass **)mono_image_alloc0 (klass->image, sizeof (MonoClass*) * interface_count);
args [0] = &klass->element_class->byval_arg;
interfaces [0] = mono_class_bind_generic_parameters (
return NULL;
/* start from the first */
if (klass->field.count) {
- return *iter = &klass->fields [0];
+ *iter = &klass->fields [0];
+ return (MonoClassField *)*iter;
} else {
/* no fields */
return NULL;
}
}
- field = *iter;
+ field = (MonoClassField *)*iter;
field++;
if (field < &klass->fields [klass->field.count]) {
- return *iter = field;
+ *iter = field;
+ return (MonoClassField *)*iter;
}
return NULL;
}
for (i = 0; i < ifaces->len; ++i) {
int j, offset;
gboolean found = FALSE;
- ic = g_ptr_array_index (ifaces, i);
+ ic = (MonoClass *)g_ptr_array_index (ifaces, i);
offset = mono_class_interface_offset (method->klass, ic);
for (j = 0; j < ic->method.count; ++j) {
if (method->klass->vtable [j + offset] == method) {
int i;
for (i = 0; i < ifaces->len; ++i) {
MonoClass *ic = NULL;
- ic = g_ptr_array_index (ifaces, i);
+ ic = (MonoClass *)g_ptr_array_index (ifaces, i);
if (MONO_CLASS_IS_IMPORT (ic))
visible = TRUE;
g_hash_table_foreach_remove (obj->itf_hash, cominterop_rcw_interface_finalizer, NULL);
g_hash_table_destroy (obj->itf_hash);
ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (obj->iunknown);
- obj->itf_hash = obj->iunknown = NULL;
+ obj->iunknown = NULL;
+ obj->itf_hash = NULL;
mono_cominterop_unlock ();
}
}
}
if (proxy->com_object->iunknown)
ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (proxy->com_object->iunknown);
- proxy->com_object->itf_hash = proxy->com_object->iunknown = NULL;
+ proxy->com_object->iunknown = NULL;
+ proxy->com_object->itf_hash = NULL;
}
mono_gchandle_free (gchandle);
return NULL;
if (verify) {
- ccw = g_hash_table_lookup (ccw_interface_hash, ccw_entry);
+ ccw = (MonoCCW *)g_hash_table_lookup (ccw_interface_hash, ccw_entry);
}
else {
ccw = ccw_entry->ccw;
if (!ccw_interface_hash)
ccw_interface_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- ccw_list = g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
+ ccw_list = (GList *)g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
mono_cominterop_unlock ();
ccw_list_item = ccw_list;
while (ccw_list_item) {
- MonoCCW* ccw_iter = ccw_list_item->data;
+ MonoCCW* ccw_iter = (MonoCCW *)ccw_list_item->data;
if (mono_gchandle_get_target (ccw_iter->gc_handle) == object) {
ccw = ccw_iter;
break;
iface = NULL;
}
- ccw_entry = g_hash_table_lookup (ccw->vtable_hash, itf);
+ ccw_entry = (MonoCCWInterface *)g_hash_table_lookup (ccw->vtable_hash, itf);
if (!ccw_entry) {
int vtable_index = method_count-1+start_slot;
- vtable = mono_image_alloc0 (klass->image, sizeof (gpointer)*(method_count+start_slot));
+ vtable = (void **)mono_image_alloc0 (klass->image, sizeof (gpointer)*(method_count+start_slot));
memcpy (vtable, iunknown, sizeof (iunknown));
if (start_slot == 7)
memcpy (vtable+3, idispatch, sizeof (idispatch));
/* need to cache orig list address to remove from hash_table if empty */
mono_cominterop_lock ();
- ccw_list = ccw_list_orig = g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
+ ccw_list = ccw_list_orig = (GList *)g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
mono_cominterop_unlock ();
if (!ccw_list)
ccw_list_item = ccw_list;
while (ccw_list_item) {
- MonoCCW* ccw_iter = ccw_list_item->data;
+ MonoCCW* ccw_iter = (MonoCCW *)ccw_list_item->data;
MonoObject* handle_target = mono_gchandle_get_target (ccw_iter->gc_handle);
/* Looks like the GC NULLs the weakref handle target before running the
*/
gboolean destroy_ccw = !handle_target || handle_target == object;
if (!handle_target) {
- MonoCCWInterface* ccw_entry = g_hash_table_lookup (ccw_iter->vtable_hash, mono_class_get_iunknown_class ());
+ MonoCCWInterface* ccw_entry = (MonoCCWInterface *)g_hash_table_lookup (ccw_iter->vtable_hash, mono_class_get_iunknown_class ());
if (!(ccw_entry && object == cominterop_get_ccw_object (ccw_entry, FALSE)))
destroy_ccw = FALSE;
}
if (cominterop_class_guid_equal (riid, mono_class_get_iunknown_class ())) {
*ppv = cominterop_get_ccw (object, mono_class_get_iunknown_class ());
/* remember to addref on QI */
- cominterop_ccw_addref (*ppv);
+ cominterop_ccw_addref ((MonoCCWInterface *)*ppv);
return MONO_S_OK;
}
*ppv = cominterop_get_ccw (object, mono_class_get_idispatch_class ());
/* remember to addref on QI */
- cominterop_ccw_addref (*ppv);
+ cominterop_ccw_addref ((MonoCCWInterface *)*ppv);
return MONO_S_OK;
}
if (ifaces) {
for (i = 0; i < ifaces->len; ++i) {
MonoClass *ic = NULL;
- ic = g_ptr_array_index (ifaces, i);
+ ic = (MonoClass *)g_ptr_array_index (ifaces, i);
if (cominterop_class_guid_equal (riid, ic)) {
itf = ic;
break;
if (itf) {
*ppv = cominterop_get_ccw (object, itf);
/* remember to addref on QI */
- cominterop_ccw_addref (*ppv);
+ cominterop_ccw_addref ((MonoCCWInterface *)*ppv);
return MONO_S_OK;
}
if (com_provider == MONO_COM_DEFAULT) {
int slen = mono_string_length (string_obj);
/* allocate len + 1 utf16 characters plus 4 byte integer for length*/
- char *ret = g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
+ char *ret = (char *)g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
if (ret == NULL)
return NULL;
memcpy (ret + sizeof(guint32), mono_string_chars (string_obj), slen * sizeof(gunichar2));
return mono_string_new_utf16 (mono_domain_get (), bstr, SysStringLen (bstr));
#else
if (com_provider == MONO_COM_DEFAULT) {
- return mono_string_new_utf16 (mono_domain_get (), bstr, *((guint32 *)bstr - 1) / sizeof(gunichar2));
+ return mono_string_new_utf16 (mono_domain_get (), (const mono_unichar2 *)bstr, *((guint32 *)bstr - 1) / sizeof(gunichar2));
} else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
MonoString* str = NULL;
glong written = 0;
gunichar2* utf16 = NULL;
- utf16 = g_ucs4_to_utf16 (bstr, sys_string_len_ms (bstr), NULL, &written, NULL);
+ utf16 = g_ucs4_to_utf16 ((const gunichar *)bstr, sys_string_len_ms (bstr), NULL, &written, NULL);
str = mono_string_new_utf16 (mono_domain_get (), utf16, written);
g_free (utf16);
return str;
if (com_provider == MONO_COM_DEFAULT) {
g_free (((char *)bstr) - 4);
} else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
- sys_free_string_ms (bstr);
+ sys_free_string_ms ((gunichar *)bstr);
} else {
g_assert_not_reached ();
}
*indices = g_malloc (dim * sizeof(int));
- sizes = alloca (dim * sizeof(uintptr_t));
- bounds = alloca (dim * sizeof(intptr_t));
+ sizes = (uintptr_t *)alloca (dim * sizeof(uintptr_t));
+ bounds = (intptr_t *)alloca (dim * sizeof(intptr_t));
for (i=0; i<dim; ++i) {
glong lbound, ubound;
aklass = mono_bounded_array_class_get (mono_defaults.object_class, dim, bounded);
*result = mono_array_new_full (mono_domain_get (), aklass, sizes, bounds);
} else {
- *result = parameter;
+ *result = (MonoArray *)parameter;
}
}
}
}
#else
if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
- int hr = safe_array_ptr_of_index_ms (safearray, indices, &result);
+ int hr = safe_array_ptr_of_index_ms (safearray, (glong *)indices, &result);
if (hr < 0) {
cominterop_raise_hr_exception (hr);
}
dim = ((MonoObject *)input)->vtable->klass->rank;
*indices = g_malloc (dim * sizeof (int));
- bounds = alloca (dim * sizeof (SAFEARRAYBOUND));
+ bounds = (SAFEARRAYBOUND *)alloca (dim * sizeof (SAFEARRAYBOUND));
(*(int*)empty) = (max_array_length == 0);
if (dim > 1) {
cominterop_raise_hr_exception (hr);
#else
if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
- int hr = safe_array_put_element_ms (safearray, indices, value);
+ int hr = safe_array_put_element_ms (safearray, (glong *)indices, (void **)value);
if (hr < 0) {
cominterop_raise_hr_exception (hr);
}
memset (&sigwinch, 0, sizeof (struct sigaction));
// Continuing
- sigcont.sa_handler = (void *) sigcont_handler;
+ sigcont.sa_handler = (void (*)(int)) sigcont_handler;
sigcont.sa_flags = 0;
sigemptyset (&sigcont.sa_mask);
sigaction (SIGCONT, &sigcont, &save_sigcont);
// Interrupt handler
- sigint.sa_handler = (void *) sigint_handler;
+ sigint.sa_handler = (void (*)(int)) sigint_handler;
sigint.sa_flags = 0;
sigemptyset (&sigint.sa_mask);
sigaction (SIGINT, &sigint, &save_sigint);
// Window size changed
- sigwinch.sa_handler = (void *) sigwinch_handler;
+ sigwinch.sa_handler = (void (*)(int)) sigwinch_handler;
sigwinch.sa_flags = 0;
sigemptyset (&sigwinch.sa_mask);
sigaction (SIGWINCH, &sigwinch, &save_sigwinch);
if (!vtable)
return;
- if (!(addr = mono_vtable_get_static_field_data (vtable)))
+ if (!(addr = (const char *)mono_vtable_get_static_field_data (vtable)))
return;
for (p = klass; p != NULL; p = p->parent) {
static void
doc_free (gpointer key)
{
- MonoDebugSourceInfo *info = key;
+ MonoDebugSourceInfo *info = (MonoDebugSourceInfo *)key;
g_free (info->source_file);
g_free (info);
mono_debugger_lock ();
- minfo = g_hash_table_lookup (ppdb->method_hash, method);
+ minfo = (MonoDebugMethodInfo *)g_hash_table_lookup (ppdb->method_hash, method);
if (minfo) {
mono_debugger_unlock ();
return minfo;
MonoDebugSourceInfo *res, *cached;
mono_debugger_lock ();
- cached = g_hash_table_lookup (ppdb->doc_hash, GUINT_TO_POINTER (docidx));
+ cached = (MonoDebugSourceInfo *)g_hash_table_lookup (ppdb->doc_hash, GUINT_TO_POINTER (docidx));
mono_debugger_unlock ();
if (cached)
return cached;
res->hash = (guint8*)mono_metadata_blob_heap (image, cols [MONO_DOCUMENT_HASH]);
mono_debugger_lock ();
- cached = g_hash_table_lookup (ppdb->doc_hash, GUINT_TO_POINTER (docidx));
+ cached = (MonoDebugSourceInfo *)g_hash_table_lookup (ppdb->doc_hash, GUINT_TO_POINTER (docidx));
if (!cached) {
g_hash_table_insert (ppdb->doc_hash, GUINT_TO_POINTER (docidx), res);
} else {
if (raw_contents != NULL) {
unsigned char *p;
symfile->raw_contents_size = size;
- symfile->raw_contents = p = g_malloc (size);
+ symfile->raw_contents = p = (unsigned char *)g_malloc (size);
memcpy (p, raw_contents, size);
symfile->filename = g_strdup_printf ("LoadedFromMemory");
symfile->was_loaded_from_memory = TRUE;
g_warning ("stat of %s failed: %s",
symfile->filename, g_strerror (errno));
} else {
- symfile->raw_contents = mono_file_map (symfile->raw_contents_size, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (f), 0, &symfile->raw_contents_handle);
+ symfile->raw_contents = (const unsigned char *)mono_file_map (symfile->raw_contents_size, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (f), 0, &symfile->raw_contents_handle);
}
mono_file_map_close (f);
{
MonoDebugSourceInfo *info;
- info = g_hash_table_lookup (symfile->source_hash, GUINT_TO_POINTER (index));
+ info = (MonoDebugSourceInfo *)g_hash_table_lookup (symfile->source_hash, GUINT_TO_POINTER (index));
if (!info) {
int offset = read32(&(symfile->offset_table->_source_table_offset)) +
(index - 1) * sizeof (MonoSymbolFileSourceEntry);
info = g_new0 (MonoDebugSourceInfo, 1);
info->source_file = read_string (ptr, &ptr);
- info->guid = g_malloc0 (16);
+ info->guid = (guint8 *)g_malloc0 (16);
memcpy (info->guid, ptr, 16);
ptr += 16;
- info->hash = g_malloc0 (16);
+ info->hash = (guint8 *)g_malloc0 (16);
memcpy (info->hash, ptr, 16);
ptr += 16;
g_hash_table_insert (symfile->source_hash, GUINT_TO_POINTER (index), info);
guint32 flags;
if ((symfile = minfo->handle->symfile) == NULL)
- return FALSE;
+ return (LineNumberTableFlags)0;
ptr = symfile->raw_contents + minfo->data_offset;
read_leb128 (ptr, &ptr);
flags = read_leb128 (ptr, &ptr);
- return flags;
+ return (LineNumberTableFlags)flags;
}
/*
*source_file_list = g_ptr_array_new ();
if (source_files)
- *source_files = g_malloc (il_offset_array->len * sizeof (int));
+ *source_files = (int *)g_malloc (il_offset_array->len * sizeof (int));
for (i = 0; i < il_offset_array->len; ++i) {
file = GPOINTER_TO_UINT (g_ptr_array_index (source_file_array, i));
mono_debugger_lock ();
- minfo = g_hash_table_lookup (symfile->method_hash, method);
+ minfo = (MonoDebugMethodInfo *)g_hash_table_lookup (symfile->method_hash, method);
if (minfo) {
mono_debugger_unlock ();
return minfo;
first_ie = (MonoSymbolFileMethodEntry *)
(symfile->raw_contents + read32(&(symfile->offset_table->_method_table_offset)));
- ie = mono_binary_search (GUINT_TO_POINTER (mono_method_get_token (method)), first_ie,
+ ie = (MonoSymbolFileMethodEntry *)mono_binary_search (GUINT_TO_POINTER (mono_method_get_token (method)), first_ie,
read32(&(symfile->offset_table->_method_count)),
sizeof (MonoSymbolFileMethodEntry), compare_method);
for (i = 0; i < num_locals; ++i) {
res->locals [i].index = read_leb128 (p, &p);
len = read_leb128 (p, &p);
- res->locals [i].name = g_malloc (len + 1);
+ res->locals [i].name = (char *)g_malloc (len + 1);
memcpy (res->locals [i].name, p, len);
res->locals [i].name [len] = '\0';
p += len;
chunk = mp->chunks;
while (chunk) {
- next = chunk->prev;
+ next = (LockFreeMempoolChunk *)chunk->prev;
mono_vfree (chunk, mono_pagesize ());
chunk = next;
}
size = mono_pagesize ();
while (size - sizeof (LockFreeMempoolChunk) < len)
size += mono_pagesize ();
- chunk = mono_valloc (0, size, MONO_MMAP_READ|MONO_MMAP_WRITE);
+ chunk = (LockFreeMempoolChunk *)mono_valloc (0, size, MONO_MMAP_READ|MONO_MMAP_WRITE);
g_assert (chunk);
- chunk->mem = ALIGN_PTR_TO ((char*)chunk + sizeof (LockFreeMempoolChunk), 16);
+ chunk->mem = (guint8 *)ALIGN_PTR_TO ((char*)chunk + sizeof (LockFreeMempoolChunk), 16);
chunk->size = ((char*)chunk + size) - (char*)chunk->mem;
chunk->pos = 0;
int id = -1, i;
if (!appdomains_list) {
appdomain_list_size = 2;
- appdomains_list = mono_gc_alloc_fixed (appdomain_list_size * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "domains list");
+ appdomains_list = (MonoDomain **)mono_gc_alloc_fixed (appdomain_list_size * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "domains list");
}
for (i = appdomain_next; i < appdomain_list_size; ++i) {
if (!appdomains_list [i]) {
if (new_size >= (1 << 16))
g_assert_not_reached ();
id = appdomain_list_size;
- new_list = mono_gc_alloc_fixed (new_size * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "domains list");
+ new_list = (MonoDomain **)mono_gc_alloc_fixed (new_size * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "domains list");
memcpy (new_list, appdomains_list, appdomain_list_size * sizeof (void*));
mono_gc_free_fixed (appdomains_list);
appdomains_list = new_list;
* running the corlib test suite.
* To solve this, we pass a NULL descriptor, and don't register roots.
*/
- domain = mono_gc_alloc_fixed (sizeof (MonoDomain), NULL, MONO_ROOT_SOURCE_DOMAIN, "domain object");
+ domain = (MonoDomain *)mono_gc_alloc_fixed (sizeof (MonoDomain), NULL, MONO_ROOT_SOURCE_DOMAIN, "domain object");
#else
- domain = mono_gc_alloc_fixed (sizeof (MonoDomain), domain_gc_desc, MONO_ROOT_SOURCE_DOMAIN, "domain object");
+ domain = (MonoDomain *)mono_gc_alloc_fixed (sizeof (MonoDomain), domain_gc_desc, MONO_ROOT_SOURCE_DOMAIN, "domain object");
mono_gc_register_root ((char*)&(domain->MONO_DOMAIN_FIRST_GC_TRACKED), G_STRUCT_OFFSET (MonoDomain, MONO_DOMAIN_LAST_GC_TRACKED) - G_STRUCT_OFFSET (MonoDomain, MONO_DOMAIN_FIRST_GC_TRACKED), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "misc domain fields");
#endif
domain->shadow_serial = shadow_serial;
*/
mono_appdomains_lock ();
size = appdomain_list_size;
- copy = mono_gc_alloc_fixed (appdomain_list_size * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "temporary domains list");
+ copy = (MonoDomain **)mono_gc_alloc_fixed (appdomain_list_size * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, "temporary domains list");
memcpy (copy, appdomains_list, appdomain_list_size * sizeof (void*));
mono_appdomains_unlock ();
mono_domain_assemblies_lock (domain);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- ass = tmp->data;
+ ass = (MonoAssembly *)tmp->data;
if (strcmp (name, ass->aname.name) == 0) {
mono_domain_assemblies_unlock (domain);
return ass;
static void
unregister_vtable_reflection_type (MonoVTable *vtable)
{
- MonoObject *type = vtable->type;
+ MonoObject *type = (MonoObject *)vtable->type;
if (type->vtable->klass != mono_defaults.monotype_class)
MONO_GC_UNREGISTER_ROOT_IF_MOVING (vtable->type);
if (domain->class_vtable_array) {
int i;
for (i = 0; i < domain->class_vtable_array->len; ++i)
- unregister_vtable_reflection_type (g_ptr_array_index (domain->class_vtable_array, i));
+ unregister_vtable_reflection_type ((MonoVTable *)g_ptr_array_index (domain->class_vtable_array, i));
}
if (domain->type_hash) {
}
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
mono_assembly_release_gc_roots (ass);
}
/* Close dynamic assemblies first, since they have no ref count */
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (!ass->image || !image_is_dynamic (ass->image))
continue;
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", domain->friendly_name, domain, ass->aname.name, ass, ass->ref_count);
}
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (!ass)
continue;
if (!ass->image || image_is_dynamic (ass->image))
}
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (ass)
mono_assembly_close_finish (ass);
}
next = GPOINTER_TO_INT (domain->static_data_array [0]);
if (next >= size) {
/* 'data' is allocated by alloc_fixed */
- gpointer *new_array = mono_gc_alloc_fixed (sizeof (gpointer) * (size * 2), MONO_GC_ROOT_DESCR_FOR_FIXED (size * 2), MONO_ROOT_SOURCE_DOMAIN, "static field list");
+ gpointer *new_array = (gpointer *)mono_gc_alloc_fixed (sizeof (gpointer) * (size * 2), MONO_GC_ROOT_DESCR_FOR_FIXED (size * 2), MONO_ROOT_SOURCE_DOMAIN, "static field list");
mono_gc_memmove_aligned (new_array, domain->static_data_array, sizeof (gpointer) * size);
size *= 2;
new_array [1] = GINT_TO_POINTER (size);
}
} else {
int size = 32;
- gpointer *new_array = mono_gc_alloc_fixed (sizeof (gpointer) * size, MONO_GC_ROOT_DESCR_FOR_FIXED (size), MONO_ROOT_SOURCE_DOMAIN, "static field list");
+ gpointer *new_array = (gpointer *)mono_gc_alloc_fixed (sizeof (gpointer) * size, MONO_GC_ROOT_DESCR_FOR_FIXED (size), MONO_ROOT_SOURCE_DOMAIN, "static field list");
next = 2;
new_array [0] = GINT_TO_POINTER (next);
new_array [1] = GINT_TO_POINTER (size);
app_config = g_new0 (AppConfigInfo, 1);
- context = g_markup_parse_context_new (&mono_parser, 0, app_config, NULL);
+ context = g_markup_parse_context_new (&mono_parser, (GMarkupParseFlags)0, app_config, NULL);
if (g_markup_parse_context_parse (context, text, len, NULL)) {
g_markup_parse_context_end_parse (context, NULL);
}
for (i = 0; i < len; ++i) {
gpointer ip = mono_array_get (arr, gpointer, i);
- MonoJitInfo *ji = mono_jit_info_table_find (mono_domain_get (), ip);
+ MonoJitInfo *ji = mono_jit_info_table_find (mono_domain_get (), (char *)ip);
if (ji) {
char *msg = mono_debug_print_stack_frame (mono_jit_info_get_method (ji), (char*)ip - (char*)ji->code_start, domain);
g_string_append_printf (text, "%s\n", msg);
static guint32 convert_attrs(MonoFileAttributes attrs)
{
if(attrs & FileAttributes_Encrypted) {
- attrs |= FILE_ATTRIBUTE_ENCRYPTED;
+ attrs = (MonoFileAttributes)(attrs | FILE_ATTRIBUTE_ENCRYPTED);
}
return(attrs);
gchar *utf8_path = NULL, *utf8_result, *full_name;
gint32 attributes;
- mask = convert_attrs (mask);
+ mask = convert_attrs ((MonoFileAttributes)mask);
attributes = get_file_attributes (path);
if (attributes != -1) {
if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
result = mono_array_new (domain, mono_defaults.string_class, names->len);
for (i = 0; i < names->len; i++) {
- mono_array_setref (result, i, mono_string_new (domain, g_ptr_array_index (names, i)));
+ mono_array_setref (result, i, mono_string_new (domain, (const char *)g_ptr_array_index (names, i)));
g_free (g_ptr_array_index (names, i));
}
g_ptr_array_free (names, TRUE);
MonoString *
ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_attr, gint32 *error)
{
- IncrementalFind *ifh = handle;
+ IncrementalFind *ifh = (IncrementalFind *)handle;
WIN32_FIND_DATA data;
MonoString *result;
int
ves_icall_System_IO_MonoIO_FindClose (gpointer handle)
{
- IncrementalFind *ifh = handle;
+ IncrementalFind *ifh = (IncrementalFind *)handle;
gint32 error;
MONO_PREPARE_BLOCKING;
*error=ERROR_SUCCESS;
ret=SetFileAttributes (mono_string_chars (path),
- convert_attrs (attrs));
+ convert_attrs ((MonoFileAttributes)attrs));
if(ret==FALSE) {
*error=GetLastError ();
}
}
}
- ret=CreateFile (chars, convert_access (access_mode),
- convert_share (share), NULL, convert_mode (mode),
+ ret=CreateFile (chars, convert_access ((MonoFileAccess)access_mode),
+ convert_share ((MonoFileShare)share), NULL, convert_mode ((MonoFileMode)mode),
attributes, NULL);
if(ret==INVALID_HANDLE_VALUE) {
*error=GetLastError ();
offset_hi = offset >> 32;
offset = SetFilePointer (handle, (gint32) (offset & 0xFFFFFFFF), &offset_hi,
- convert_seekorigin (origin));
+ (WapiSeekMethod)convert_seekorigin ((MonoSeekOrigin)origin));
if(offset==INVALID_SET_FILE_POINTER) {
*error=GetLastError ();
*error = COULD_NOT_MAP_MEMORY;
goto done;
}
- file_name = alloca (alloc_size);
+ file_name = (char *)alloca (alloc_size);
strcpy (file_name, tmp_dir);
strcat (file_name, MONO_ANON_FILE_TEMPLATE);
*error = FILE_ALREADY_EXISTS;
handle = NULL;
} else {
- handle = open_file_map (path, -1, mode, capacity, access, options, error);
+ handle = (MmapHandle *)open_file_map (path, -1, mode, capacity, access, options, error);
if (handle) {
handle->name = g_strdup (c_mapName);
g_hash_table_insert (named_regions, handle->name, handle);
{
MmapHandle *handle;
if (!mapName) {
- handle = open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, error);
+ handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, error);
} else {
char *c_mapName = mono_string_to_utf8 (mapName);
handle = NULL;
} else {
//XXX we're exploiting wapi HANDLE == FD equivalence. THIS IS FRAGILE, create a _wapi_handle_to_fd call
- handle = open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, error);
+ handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, error);
handle->name = g_strdup (c_mapName);
g_hash_table_insert (named_regions, handle->name, handle);
}
void
mono_mmap_close (void *mmap_handle)
{
- MmapHandle *handle = mmap_handle;
+ MmapHandle *handle = (MmapHandle *)mmap_handle;
named_regions_lock ();
--handle->ref_count;
void
mono_mmap_configure_inheritability (void *mmap_handle, gboolean inheritability)
{
- MmapHandle *h = mmap_handle;
+ MmapHandle *h = (MmapHandle *)mmap_handle;
int fd, flags;
fd = h->fd;
void
mono_mmap_flush (void *mmap_handle)
{
- MmapInstance *h = mmap_handle;
+ MmapInstance *h = (MmapInstance *)mmap_handle;
if (h)
msync (h->address, h->length, MS_SYNC);
mono_mmap_map (void *handle, gint64 offset, gint64 *size, int access, void **mmap_handle, void **base_address)
{
gint64 mmap_offset = 0;
- MmapHandle *fh = handle;
+ MmapHandle *fh = (MmapHandle *)handle;
MmapInstance res = { 0 };
size_t eff_size = *size;
struct stat buf = { 0 };
mono_mmap_unmap (void *mmap_handle)
{
int res = 0;
- MmapInstance *h = mmap_handle;
+ MmapInstance *h = (MmapInstance *)mmap_handle;
res = mono_file_unmap (h->address, h->free_handle);
#ifndef HAVE_SGEN_GC
mono_domain_finalizers_lock (domain);
- o2 = g_hash_table_lookup (domain->finalizable_objects_hash, o);
+ o2 = (MonoObject *)g_hash_table_lookup (domain->finalizable_objects_hash, o);
mono_domain_finalizers_unlock (domain);
#endif
/* make sure the finalizer is not called again if the object is resurrected */
- object_register_finalizer (obj, NULL);
+ object_register_finalizer ((MonoObject *)obj, NULL);
if (log_finalizers)
g_log ("mono-gc-finalizers", G_LOG_LEVEL_MESSAGE, "<%s at %p> Registered finalizer as processed.", o->vtable->klass->name, o);
domain->finalize_runtime_invoke = mono_compile_method (invoke);
}
- runtime_invoke = domain->finalize_runtime_invoke;
+ runtime_invoke = (RuntimeInvokeFunction)domain->finalize_runtime_invoke;
mono_runtime_class_init (o->vtable);
if (domains_to_finalize) {
mono_finalizer_lock ();
if (domains_to_finalize) {
- DomainFinalizationReq *req = domains_to_finalize->data;
+ DomainFinalizationReq *req = (DomainFinalizationReq *)domains_to_finalize->data;
domains_to_finalize = g_slist_remove (domains_to_finalize, req);
mono_finalizer_unlock ();
/* Guard if head is changed concurrently. */
while (*prev != element)
prev = &(*prev)->next;
- } while (prev && InterlockedCompareExchangePointer ((void*)prev, element->next, element) != element);
+ } while (prev && InterlockedCompareExchangePointer ((volatile gpointer *)prev, element->next, element) != element);
}
static void
current = *head;
value->next = current;
STORE_STORE_FENCE; /*Must make sure the previous store is visible before the CAS. */
- } while (InterlockedCompareExchangePointer ((void*)head, value, current) != current);
+ } while (InterlockedCompareExchangePointer ((volatile gpointer *)head, value, current) != current);
}
static void
if (ac->element_class->valuetype)
return mono_value_box (arr->obj.vtable->domain, ac->element_class, ea);
else
- return *ea;
+ return (MonoObject *)*ea;
}
ICALL_EXPORT MonoObject *
aklass = mono_bounded_array_class_get (klass, mono_array_length (lengths), bounded);
- sizes = alloca (aklass->rank * sizeof(intptr_t) * 2);
+ sizes = (uintptr_t *)alloca (aklass->rank * sizeof(intptr_t) * 2);
for (i = 0; i < aklass->rank; ++i) {
sizes [i] = mono_array_get (lengths, guint32, i);
if (bounds)
aklass = mono_bounded_array_class_get (klass, mono_array_length (lengths), bounded);
- sizes = alloca (aklass->rank * sizeof(intptr_t) * 2);
+ sizes = (uintptr_t *)alloca (aklass->rank * sizeof(intptr_t) * 2);
for (i = 0; i < aklass->rank; ++i) {
sizes [i] = mono_array_get (lengths, guint64, i);
if (bounds)
if (MONO_TYPE_IS_REFERENCE (&ec->byval_arg)) {
g_assert (esize == sizeof (gpointer));
- mono_gc_wbarrier_generic_store (ea, *(gpointer*)value);
+ mono_gc_wbarrier_generic_store (ea, *(MonoObject **)value);
} else {
g_assert (ec->inited);
g_assert (esize == mono_class_value_size (ec, NULL));
ICALL_EXPORT MonoObject*
ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilder *mb, guint32 token)
{
- gpointer obj;
+ MonoObject *obj;
mono_loader_lock ();
- obj = mono_g_hash_table_lookup (mb->dynamic_image->tokens, GUINT_TO_POINTER (token));
+ obj = (MonoObject *)mono_g_hash_table_lookup (mb->dynamic_image->tokens, GUINT_TO_POINTER (token));
mono_loader_unlock ();
return obj;
static gboolean
get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
- MonoMethod **dest = data;
+ MonoMethod **dest = (MonoMethod **)data;
/* skip unmanaged frames */
if (!managed)
static gboolean
get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
- MonoMethod **dest = data;
+ MonoMethod **dest = (MonoMethod **)data;
/* skip unmanaged frames */
if (!managed)
static gboolean
get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
- MonoMethod **dest = data;
+ MonoMethod **dest = (MonoMethod **)data;
/* skip unmanaged frames */
if (!managed)
*/
nullable = mono_object_new (mono_domain_get (), nklass);
- mono_nullable_init (mono_object_unbox (nullable), value, nklass);
+ mono_nullable_init ((guint8 *)mono_object_unbox (nullable), value, nklass);
- v = mono_object_unbox (nullable);
+ v = (gchar *)mono_object_unbox (nullable);
}
else
if (gclass->container_class->valuetype && (v != NULL))
static void
fill_iface_array (gpointer key, gpointer value, gpointer user_data)
{
- FillIfaceArrayData *data = user_data;
- MonoClass *ic = key;
+ FillIfaceArrayData *data = (FillIfaceArrayData *)user_data;
+ MonoClass *ic = (MonoClass *)key;
MonoType *ret = &ic->byval_arg, *inflated = NULL;
if (!mono_error_ok (data->error))
tb = mono_class_get_ref_info (generic_class);
if (generic_class->wastypebuilder && tb)
- return tb;
+ return (MonoReflectionType *)tb;
else
return mono_type_get_object (mono_object_domain (type), &generic_class->byval_arg);
}
types = g_new0 (MonoType *, count);
for (i = 0; i < count; i++) {
- MonoReflectionType *t = mono_array_get (type_array, gpointer, i);
+ MonoReflectionType *t = (MonoReflectionType *)mono_array_get (type_array, gpointer, i);
types [i] = t->type;
}
{
g_assert (IS_MONOTYPE (type));
g_assert (is_generic_parameter (type->type));
- return mono_generic_param_info (type->type->data.generic_param)->flags;
+ return (GenericParameterAttributes)mono_generic_param_info (type->type->data.generic_param)->flags;
}
ICALL_EXPORT MonoArray *
if (image_is_dynamic (image)) {
MonoReflectionMethodAux *method_aux =
- g_hash_table_lookup (((MonoDynamicImage*)image)->method_aux_hash, method->method);
+ (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)image)->method_aux_hash, method->method);
if (method_aux) {
import = method_aux->dllentry;
scope = method_aux->dll;
* the dynamic case as well ?
*/
mono_image_lock ((MonoImage*)image);
- res = mono_g_hash_table_lookup (image->generic_def_objects, imethod);
+ res = (MonoReflectionMethod *)mono_g_hash_table_lookup (image->generic_def_objects, imethod);
mono_image_unlock ((MonoImage*)image);
if (res)
uintptr_t *lengths;
intptr_t *lower_bounds;
pcount = mono_array_length (params);
- lengths = alloca (sizeof (uintptr_t) * pcount);
+ lengths = (uintptr_t *)alloca (sizeof (uintptr_t) * pcount);
/* Note: the synthetized array .ctors have int32 as argument type */
for (i = 0; i < pcount; ++i)
lengths [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, i) + sizeof (MonoObject));
} else {
g_assert (pcount == (m->klass->rank * 2));
/* The arguments are lower-bound-length pairs */
- lower_bounds = g_alloca (sizeof (intptr_t) * pcount);
+ lower_bounds = (intptr_t *)g_alloca (sizeof (intptr_t) * pcount);
for (i = 0; i < pcount / 2; ++i) {
lower_bounds [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, (i * 2)) + sizeof (MonoObject));
if (field_klass->valuetype)
result = mono_value_box (domain, field_klass, (char *)this_arg + field->offset);
else
- result = *((gpointer *)((char *)this_arg + field->offset));
+ result = (MonoObject *)*((gpointer *)((char *)this_arg + field->offset));
out_args = mono_array_new (domain, mono_defaults.object_class, 1);
mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
MonoClassField* field = mono_class_get_field_from_name (k, str);
if (field) {
MonoClass *field_klass = mono_class_from_mono_type (field->type);
- MonoObject *val = mono_array_get (params, gpointer, 2);
+ MonoObject *val = (MonoObject *)mono_array_get (params, gpointer, 2);
if (field_klass->valuetype) {
size = mono_type_size (field->type, &align);
}
case MONO_TYPE_U2:
case MONO_TYPE_I2: {
- guint16 *p = (void*)mem;
+ guint16 *p = (guint16 *)mem;
*p = value;
break;
}
case MONO_TYPE_U4:
case MONO_TYPE_I4: {
- guint32 *p = (void*)mem;
+ guint32 *p = (guint32 *)mem;
*p = value;
break;
}
case MONO_TYPE_U8:
case MONO_TYPE_I8: {
- guint64 *p = (void*)mem;
+ guint64 *p = (guint64 *)mem;
*p = value;
break;
}
res = mono_array_new_specific (array_vtable, method_array->len);
for (i = 0; i < method_array->len; ++i) {
- MonoMethod *method = g_ptr_array_index (method_array, i);
+ MonoMethod *method = (MonoMethod *)g_ptr_array_index (method_array, i);
mono_array_setref (res, i, mono_method_get_object (domain, method, refklass));
}
ex_count = 0;
for (i = 0; i < len; i++) {
- MonoReflectionType *t = mono_array_get (res, gpointer, i);
+ MonoReflectionType *t = (MonoReflectionType *)mono_array_get (res, gpointer, i);
MonoClass *klass;
if (t) {
exl = mono_array_new (domain, mono_defaults.exception_class, length);
/* Types for which mono_class_get_checked () succeeded */
for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
- MonoException *exc = mono_class_get_exception_for_failure (tmp->data);
+ MonoException *exc = mono_class_get_exception_for_failure ((MonoClass *)tmp->data);
mono_array_setref (exl, i, exc);
}
/* Types for which it don't */
if (image_is_dynamic (image)) {
if ((table == MONO_TABLE_TYPEDEF) || (table == MONO_TABLE_TYPEREF)) {
- klass = mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
return klass ? &klass->byval_arg : NULL;
}
init_generic_context_from_args (&context, type_args, method_args);
- klass = mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
+ klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
return klass ? &klass->byval_arg : NULL;
}
if (image_is_dynamic (image)) {
if (table == MONO_TABLE_METHOD)
- return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ return (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
if ((table == MONO_TABLE_MEMBERREF) && !(mono_memberref_is_method (image, token))) {
*resolve_error = ResolveTokenError_BadTable;
}
init_generic_context_from_args (&context, type_args, method_args);
- return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
+ return (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
}
if ((index <= 0) || (index > image->tables [table].rows)) {
}
if (image_is_dynamic (image))
- return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ return (MonoString *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
if ((index <= 0) || (index >= image->heap_us.size)) {
*error = ResolveTokenError_OutOfRange;
if (image_is_dynamic (image)) {
if (table == MONO_TABLE_FIELD)
- return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ return (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
if (mono_memberref_is_method (image, token)) {
*resolve_error = ResolveTokenError_BadTable;
}
init_generic_context_from_args (&context, type_args, method_args);
- return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
+ return (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
}
if ((index <= 0) || (index > image->tables [table].rows)) {
tp->custom_type_info = (mono_object_isinst (this_obj, mono_defaults.iremotingtypeinfo_class) != NULL);
tp->remote_class = mono_remote_class (domain, class_name, klass);
- res->vtable = mono_remote_class_vtable (domain, tp->remote_class, rp);
+ res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp);
return res;
}
if (size > initial_size) {
if (ptr != buf)
g_free (ptr);
- ptr = g_malloc0 ((size + 1) * sizeof (gunichar2));
+ ptr = (gunichar2 *)g_malloc0 ((size + 1) * sizeof (gunichar2));
initial_size = size;
size++;
}
return NULL;
len = config_file_path_length - config_ext_length;
- module = g_malloc0 (len + 1);
+ module = (gchar *)g_malloc0 (len + 1);
memcpy (module, config_file_path, len);
// Get the config file from the module name
app_config = mono_config_string_for_assembly_file (module);
*result = NULL;
*size = 0;
image = assembly->assembly->image;
- entry = mono_image_lookup_resource (image, MONO_PE_RESOURCE_ID_ASPNET_STRING, 0, NULL);
+ entry = (MonoPEResourceDataEntry *)mono_image_lookup_resource (image, MONO_PE_RESOURCE_ID_ASPNET_STRING, 0, NULL);
if (!entry)
return FALSE;
mono_TypedReference_ToObject (MonoTypedRef* tref)
{
if (MONO_TYPE_IS_REFERENCE (tref->type)) {
- MonoObject** objp = tref->value;
+ MonoObject** objp = (MonoObject **)tref->value;
return *objp;
}
static gpointer
find_method_icall (const IcallTypeDesc *imap, const char *name)
{
- const guint16 *nameslot = mono_binary_search (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap);
+ const guint16 *nameslot = (const guint16 *)mono_binary_search (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap);
if (!nameslot)
return NULL;
return (gpointer)icall_functions [(nameslot - &icall_names_idx [0])];
static const IcallTypeDesc*
find_class_icalls (const char *name)
{
- const guint16 *nameslot = mono_binary_search (name, icall_type_names_idx, Icall_type_num, sizeof (icall_type_names_idx [0]), compare_class_imap);
+ const guint16 *nameslot = (const guint16 *)mono_binary_search (name, icall_type_names_idx, Icall_type_num, sizeof (icall_type_names_idx [0]), compare_class_imap);
if (!nameslot)
return NULL;
return &icall_type_descs [nameslot - &icall_type_names_idx [0]];
}
static MonoType*
-type_from_typename (char *typename)
+type_from_typename (char *type_name)
{
MonoClass *klass = NULL; /* assignment to shut GCC warning up */
- if (!strcmp (typename, "int"))
+ if (!strcmp (type_name, "int"))
klass = mono_defaults.int_class;
- else if (!strcmp (typename, "ptr"))
+ else if (!strcmp (type_name, "ptr"))
klass = mono_defaults.int_class;
- else if (!strcmp (typename, "void"))
+ else if (!strcmp (type_name, "void"))
klass = mono_defaults.void_class;
- else if (!strcmp (typename, "int32"))
+ else if (!strcmp (type_name, "int32"))
klass = mono_defaults.int32_class;
- else if (!strcmp (typename, "uint32"))
+ else if (!strcmp (type_name, "uint32"))
klass = mono_defaults.uint32_class;
- else if (!strcmp (typename, "int8"))
+ else if (!strcmp (type_name, "int8"))
klass = mono_defaults.sbyte_class;
- else if (!strcmp (typename, "uint8"))
+ else if (!strcmp (type_name, "uint8"))
klass = mono_defaults.byte_class;
- else if (!strcmp (typename, "int16"))
+ else if (!strcmp (type_name, "int16"))
klass = mono_defaults.int16_class;
- else if (!strcmp (typename, "uint16"))
+ else if (!strcmp (type_name, "uint16"))
klass = mono_defaults.uint16_class;
- else if (!strcmp (typename, "long"))
+ else if (!strcmp (type_name, "long"))
klass = mono_defaults.int64_class;
- else if (!strcmp (typename, "ulong"))
+ else if (!strcmp (type_name, "ulong"))
klass = mono_defaults.uint64_class;
- else if (!strcmp (typename, "float"))
+ else if (!strcmp (type_name, "float"))
klass = mono_defaults.single_class;
- else if (!strcmp (typename, "double"))
+ else if (!strcmp (type_name, "double"))
klass = mono_defaults.double_class;
- else if (!strcmp (typename, "object"))
+ else if (!strcmp (type_name, "object"))
klass = mono_defaults.object_class;
- else if (!strcmp (typename, "obj"))
+ else if (!strcmp (type_name, "obj"))
klass = mono_defaults.object_class;
- else if (!strcmp (typename, "string"))
+ else if (!strcmp (type_name, "string"))
klass = mono_defaults.string_class;
- else if (!strcmp (typename, "bool"))
+ else if (!strcmp (type_name, "bool"))
klass = mono_defaults.boolean_class;
- else if (!strcmp (typename, "boolean"))
+ else if (!strcmp (type_name, "boolean"))
klass = mono_defaults.boolean_class;
else {
- g_error ("%s", typename);
+ g_error ("%s", type_name);
g_assert_not_reached ();
}
return &klass->byval_arg;
MonoImage *corlib = mono_defaults.corlib;
mono_image_lock (corlib);
- res = g_hash_table_lookup (corlib->helper_signatures, sigstr);
+ res = (MonoMethodSignature *)g_hash_table_lookup (corlib->helper_signatures, sigstr);
mono_image_unlock (corlib);
if (res)
g_strfreev (parts);
mono_image_lock (corlib);
- res2 = g_hash_table_lookup (corlib->helper_signatures, sigstr);
+ res2 = (MonoMethodSignature *)g_hash_table_lookup (corlib->helper_signatures, sigstr);
if (res2)
res = res2; /*Value is allocated in the image pool*/
else
g_assert (jit_icall_hash_name);
mono_icall_lock ();
- info = g_hash_table_lookup (jit_icall_hash_name, name);
+ info = (MonoJitICallInfo *)g_hash_table_lookup (jit_icall_hash_name, name);
mono_icall_unlock ();
return info;
}
g_assert (jit_icall_hash_addr);
mono_icall_lock ();
- info = g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr);
+ info = (MonoJitICallInfo *)g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr);
mono_icall_unlock ();
return info;
const char *res = NULL;
mono_icall_lock ();
- info = g_hash_table_lookup (jit_icall_hash_name, name);
+ info = (MonoJitICallInfo *)g_hash_table_lookup (jit_icall_hash_name, name);
if (info)
res = info->c_symbol;
mono_icall_unlock ();
ImageUnloadHook *hook;
for (l = image_unload_hooks; l; l = l->next) {
- hook = l->data;
+ hook = (ImageUnloadHook *)l->data;
if (hook->func == func && hook->user_data == user_data) {
g_free (hook);
ImageUnloadHook *hook;
for (l = image_unload_hooks; l; l = l->next) {
- hook = l->data;
+ hook = (ImageUnloadHook *)l->data;
hook->func (image, hook->user_data);
}
guint32
mono_cli_rva_image_map (MonoImage *image, guint32 addr)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
const int top = iinfo->cli_section_count;
MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
char *
mono_image_rva_map (MonoImage *image, guint32 addr)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
const int top = iinfo->cli_section_count;
MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
int
mono_image_ensure_section_idx (MonoImage *image, int section)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoSectionTable *sect;
g_return_val_if_fail (section < iinfo->cli_section_count, FALSE);
int
mono_image_ensure_section (MonoImage *image, const char *section)
{
- MonoCLIImageInfo *ii = image->image_info;
+ MonoCLIImageInfo *ii = (MonoCLIImageInfo *)image->image_info;
int i;
for (i = 0; i < ii->cli_section_count; i++){
static gpointer
class_key_extract (gpointer value)
{
- MonoClass *klass = value;
+ MonoClass *klass = (MonoClass *)value;
return GUINT_TO_POINTER (klass->type_token);
}
static gpointer*
class_next_value (gpointer value)
{
- MonoClass *klass = value;
+ MonoClass *klass = (MonoClass *)value;
return (gpointer*)&klass->next_class_cache;
}
MonoMSDOSHeader msdos;
gint32 offset = 0;
- iinfo = image->image_info;
+ iinfo = (MonoCLIImageInfo *)image->image_info;
header = &iinfo->cli_header;
#ifdef HOST_WIN32
MonoCLIImageInfo *iinfo;
MonoDotNetHeader *header;
- iinfo = image->image_info;
+ iinfo = (MonoCLIImageInfo *)image->image_info;
header = &iinfo->cli_header;
/* Load the CLI header */
mono_image_init (image);
- iinfo = image->image_info;
+ iinfo = (MonoCLIImageInfo *)image->image_info;
header = &iinfo->cli_header;
if (!image->metadata_only) {
for (l = image_loaders; l; l = l->next) {
- MonoImageLoader *loader = l->data;
+ MonoImageLoader *loader = (MonoImageLoader *)l->data;
if (loader->match (image)) {
image->loader = loader;
break;
invalid_image:
if (errors) {
- MonoVerifyInfo *info = errors->data;
+ MonoVerifyInfo *info = (MonoVerifyInfo *)errors->data;
g_warning ("Could not load image %s due to %s", image->name, info->message);
mono_free_verify_list (errors);
}
image = g_new0 (MonoImage, 1);
image->raw_buffer_used = TRUE;
image->raw_data_len = mono_file_map_size (filed);
- image->raw_data = mono_file_map (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
+ image->raw_data = (char *)mono_file_map (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
#if defined(HAVE_MMAP) && !defined (HOST_WIN32)
if (!image->raw_data) {
image->fileio_used = TRUE;
- image->raw_data = mono_file_map_fileio (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
+ image->raw_data = (char *)mono_file_map_fileio (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
}
#endif
if (!image->raw_data) {
MonoImage *res;
mono_images_lock ();
- res = g_hash_table_lookup (get_loaded_images_hash (refonly), name);
+ res = (MonoImage *)g_hash_table_lookup (get_loaded_images_hash (refonly), name);
if (!res)
- res = g_hash_table_lookup (get_loaded_images_by_name_hash (refonly), name);
+ res = (MonoImage *)g_hash_table_lookup (get_loaded_images_by_name_hash (refonly), name);
mono_images_unlock ();
return res;
static void
find_by_guid (gpointer key, gpointer val, gpointer user_data)
{
- GuidData *data = user_data;
+ GuidData *data = (GuidData *)user_data;
MonoImage *image;
if (data->res)
return;
- image = val;
+ image = (MonoImage *)val;
if (strcmp (data->guid, mono_image_get_guid (image)) == 0)
data->res = image;
}
GHashTable *loaded_images = get_loaded_images_hash (image->ref_only);
mono_images_lock ();
- image2 = g_hash_table_lookup (loaded_images, image->name);
+ image2 = (MonoImage *)g_hash_table_lookup (loaded_images, image->name);
if (image2) {
/* Somebody else beat us to it */
}
datac = data;
if (need_copy) {
- datac = g_try_malloc (data_len);
+ datac = (char *)g_try_malloc (data_len);
if (!datac) {
if (status)
*status = MONO_IMAGE_ERROR_ERRNO;
* the same image, we discard all but the first copy.
*/
mono_images_lock ();
- image = g_hash_table_lookup (loaded_images, absfname);
+ image = (MonoImage *)g_hash_table_lookup (loaded_images, absfname);
g_free (absfname);
if (image) { // Image already loaded
loaded_images = get_loaded_images_hash (image->ref_only);
loaded_images_by_name = get_loaded_images_by_name_hash (image->ref_only);
- image2 = g_hash_table_lookup (loaded_images, image->name);
+ image2 = (MonoImage *)g_hash_table_lookup (loaded_images, image->name);
if (image == image2) {
/* This is not true if we are called from mono_image_open () */
g_hash_table_remove (loaded_images, image->name);
if (image->raw_data_allocated) {
/* FIXME: do we need this? (image is disposed anyway) */
/* image->raw_metadata and cli_sections might lie inside image->raw_data */
- MonoCLIImageInfo *ii = image->image_info;
+ MonoCLIImageInfo *ii = (MonoCLIImageInfo *)image->image_info;
if ((image->raw_metadata > image->raw_data) &&
(image->raw_metadata <= (image->raw_data + image->raw_data_len)))
mono_bitset_free (image->interface_bitset);
}
if (image->image_info){
- MonoCLIImageInfo *ii = image->image_info;
+ MonoCLIImageInfo *ii = (MonoCLIImageInfo *)image->image_info;
if (ii->cli_section_tables)
g_free (ii->cli_section_tables);
mono_image_ensure_section_idx (image, MONO_SECTION_RSRC);
- info=image->image_info;
+ info = (MonoCLIImageInfo *)image->image_info;
if(info==NULL) {
return(NULL);
}
const char*
mono_image_get_resource (MonoImage *image, guint32 offset, guint32 *size)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoCLIHeader *ch = &iinfo->cli_cli_header;
const char* data;
const char*
mono_image_get_strong_name (MonoImage *image, guint32 *size)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoPEDirEntry *de = &iinfo->cli_cli_header.ch_strong_name;
const char* data;
guint32
mono_image_strong_name_position (MonoImage *image, guint32 *size)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoPEDirEntry *de = &iinfo->cli_cli_header.ch_strong_name;
guint32 pos;
gboolean
mono_image_has_authenticode_entry (MonoImage *image)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoDotNetHeader *header = &iinfo->cli_header;
MonoPEDirEntry *de = &header->datadir.pe_certificate_table;
// the Authenticode "pre" (non ASN.1) header is 8 bytes long
{
GList *new_list;
- new_list = mono_image_alloc (image, sizeof (GList));
+ new_list = (GList *)mono_image_alloc (image, sizeof (GList));
new_list->data = data;
new_list->prev = list ? list->prev : NULL;
new_list->next = list;
{
GSList *new_list;
- new_list = mono_image_alloc (image, sizeof (GSList));
+ new_list = (GSList *)mono_image_alloc (image, sizeof (GSList));
new_list->data = data;
new_list->next = NULL;
MonoJitInfoTable *
mono_jit_info_table_new (MonoDomain *domain)
{
- MonoJitInfoTable *table = g_malloc0 (MONO_SIZEOF_JIT_INFO_TABLE + sizeof (MonoJitInfoTableChunk*));
+ MonoJitInfoTable *table = (MonoJitInfoTable *)g_malloc0 (MONO_SIZEOF_JIT_INFO_TABLE + sizeof (MonoJitInfoTableChunk*));
table->domain = domain;
table->num_chunks = 1;
while (left < right) {
int pos = (left + right) / 2;
- MonoJitInfo *ji = get_hazardous_pointer((gpointer volatile*)&chunk->data [pos], hp, JIT_INFO_HAZARD_INDEX);
+ MonoJitInfo *ji = (MonoJitInfo *)get_hazardous_pointer((gpointer volatile*)&chunk->data [pos], hp, JIT_INFO_HAZARD_INDEX);
gint8 *code_end = (gint8*)ji->code_start + ji->code_size;
if (addr < code_end)
MonoJitInfoTableChunk *chunk = table->chunks [chunk_pos];
while (pos < chunk->num_elements) {
- ji = get_hazardous_pointer ((gpointer volatile*)&chunk->data [pos], hp, JIT_INFO_HAZARD_INDEX);
+ ji = (MonoJitInfo *)get_hazardous_pointer ((gpointer volatile*)&chunk->data [pos], hp, JIT_INFO_HAZARD_INDEX);
++pos;
table by a hazard pointer and make sure that the pointer is
still there after we've made it hazardous, we don't have to
worry about the writer freeing the table. */
- table = get_hazardous_pointer ((gpointer volatile*)&domain->jit_info_table, hp, JIT_INFO_TABLE_HAZARD_INDEX);
+ table = (MonoJitInfoTable *)get_hazardous_pointer ((gpointer volatile*)&domain->jit_info_table, hp, JIT_INFO_TABLE_HAZARD_INDEX);
ji = jit_info_table_find (table, hp, (gint8*)addr);
if (hp)
/* Maybe its an AOT module */
if (try_aot && mono_get_root_domain () && mono_get_root_domain ()->aot_modules) {
- table = get_hazardous_pointer ((gpointer volatile*)&mono_get_root_domain ()->aot_modules, hp, JIT_INFO_TABLE_HAZARD_INDEX);
+ table = (MonoJitInfoTable *)get_hazardous_pointer ((gpointer volatile*)&mono_get_root_domain ()->aot_modules, hp, JIT_INFO_TABLE_HAZARD_INDEX);
module_ji = jit_info_table_find (table, hp, (gint8*)addr);
if (module_ji)
ji = jit_info_find_in_aot_func (domain, module_ji->d.image, addr);
int required_size;
int num_chunks;
int new_chunk, new_element;
- MonoJitInfoTable *new;
+ MonoJitInfoTable *result;
/* number of needed places for elements needed */
required_size = (int)((long)num_elements * JIT_INFO_TABLE_FILL_RATIO_DENOM / JIT_INFO_TABLE_FILL_RATIO_NOM);
}
g_assert (num_chunks > 0);
- new = g_malloc (MONO_SIZEOF_JIT_INFO_TABLE + sizeof (MonoJitInfoTableChunk*) * num_chunks);
- new->domain = old->domain;
- new->num_chunks = num_chunks;
+ result = (MonoJitInfoTable *)g_malloc (MONO_SIZEOF_JIT_INFO_TABLE + sizeof (MonoJitInfoTableChunk*) * num_chunks);
+ result->domain = old->domain;
+ result->num_chunks = num_chunks;
for (i = 0; i < num_chunks; ++i)
- new->chunks [i] = jit_info_table_new_chunk ();
+ result->chunks [i] = jit_info_table_new_chunk ();
new_chunk = 0;
new_element = 0;
for (j = 0; j < chunk_num_elements; ++j) {
if (!IS_JIT_INFO_TOMBSTONE (chunk->data [j])) {
g_assert (new_chunk < num_chunks);
- new->chunks [new_chunk]->data [new_element] = chunk->data [j];
+ result->chunks [new_chunk]->data [new_element] = chunk->data [j];
if (++new_element >= JIT_INFO_TABLE_FILLED_NUM_ELEMENTS) {
- new->chunks [new_chunk]->num_elements = new_element;
+ result->chunks [new_chunk]->num_elements = new_element;
++new_chunk;
new_element = 0;
}
if (new_chunk < num_chunks) {
g_assert (new_chunk == num_chunks - 1);
- new->chunks [new_chunk]->num_elements = new_element;
- g_assert (new->chunks [new_chunk]->num_elements > 0);
+ result->chunks [new_chunk]->num_elements = new_element;
+ g_assert (result->chunks [new_chunk]->num_elements > 0);
}
for (i = 0; i < num_chunks; ++i) {
- MonoJitInfoTableChunk *chunk = new->chunks [i];
+ MonoJitInfoTableChunk *chunk = result->chunks [i];
MonoJitInfo *ji = chunk->data [chunk->num_elements - 1];
- new->chunks [i]->last_code_end = (gint8*)ji->code_start + ji->code_size;
+ result->chunks [i]->last_code_end = (gint8*)ji->code_start + ji->code_size;
}
- return new;
+ return result;
}
static void
static MonoJitInfoTable*
jit_info_table_copy_and_split_chunk (MonoJitInfoTable *table, MonoJitInfoTableChunk *chunk)
{
- MonoJitInfoTable *new_table = g_malloc (MONO_SIZEOF_JIT_INFO_TABLE
+ MonoJitInfoTable *new_table = (MonoJitInfoTable *)g_malloc (MONO_SIZEOF_JIT_INFO_TABLE
+ sizeof (MonoJitInfoTableChunk*) * (table->num_chunks + 1));
int i, j;
static MonoJitInfoTableChunk*
jit_info_table_purify_chunk (MonoJitInfoTableChunk *old)
{
- MonoJitInfoTableChunk *new = jit_info_table_new_chunk ();
+ MonoJitInfoTableChunk *result = jit_info_table_new_chunk ();
int i, j;
j = 0;
for (i = 0; i < old->num_elements; ++i) {
if (!IS_JIT_INFO_TOMBSTONE (old->data [i]))
- new->data [j++] = old->data [i];
+ result->data [j++] = old->data [i];
}
- new->num_elements = j;
- if (new->num_elements > 0)
- new->last_code_end = (gint8*)new->data [j - 1]->code_start + new->data [j - 1]->code_size;
+ result->num_elements = j;
+ if (result->num_elements > 0)
+ result->last_code_end = (gint8*)result->data [j - 1]->code_start + result->data [j - 1]->code_size;
else
- new->last_code_end = old->last_code_end;
+ result->last_code_end = old->last_code_end;
- return new;
+ return result;
}
static MonoJitInfoTable*
jit_info_table_copy_and_purify_chunk (MonoJitInfoTable *table, MonoJitInfoTableChunk *chunk)
{
- MonoJitInfoTable *new_table = g_malloc (MONO_SIZEOF_JIT_INFO_TABLE
+ MonoJitInfoTable *new_table = (MonoJitInfoTable *)g_malloc (MONO_SIZEOF_JIT_INFO_TABLE
+ sizeof (MonoJitInfoTableChunk*) * table->num_chunks);
int i, j;
gpointer start = ji->code_start;
int chunk_pos, pos;
- chunk_pos = jit_info_table_index (table, start);
+ chunk_pos = jit_info_table_index (table, (gint8 *)start);
g_assert (chunk_pos < table->num_chunks);
- pos = jit_info_table_chunk_index (table->chunks [chunk_pos], NULL, start);
+ pos = jit_info_table_chunk_index (table->chunks [chunk_pos], NULL, (gint8 *)start);
do {
chunk = table->chunks [chunk_pos];
MonoTableInfo *tables = image->tables;
MonoType *sig_type;
guint32 cols[6];
- guint32 nindex, class;
+ guint32 nindex, class_index;
const char *fname;
const char *ptr;
guint32 idx = mono_metadata_token_index (token);
mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS;
- class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
+ class_index = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
if (!mono_verifier_verify_memberref_field_signature (image, cols [MONO_MEMBERREF_SIGNATURE], NULL)) {
- mono_error_set_bad_image (error, image, "Bad field '%s' signature 0x%08x", class, token);
+ mono_error_set_bad_image (error, image, "Bad field '%s' signature 0x%08x", class_index, token);
return NULL;
}
- switch (class) {
+ switch (class_index) {
case MONO_MEMBERREF_PARENT_TYPEDEF:
klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF | nindex, error);
break;
klass = mono_class_get_and_inflate_typespec_checked (image, MONO_TOKEN_TYPE_SPEC | nindex, context, error);
break;
default:
- mono_error_set_bad_image (error, image, "Bad field field '%s' signature 0x%08x", class, token);
+ mono_error_set_bad_image (error, image, "Bad field field '%s' signature 0x%08x", class_index, token);
}
if (!klass)
/* we may want to check the signature here... */
if (*ptr++ != 0x6) {
- mono_error_set_field_load (error, klass, fname, "Bad field signature class token %08x field name %s token %08x", class, fname, token);
+ mono_error_set_field_load (error, klass, fname, "Bad field signature class token %08x field name %s token %08x", class_index, fname, token);
return NULL;
}
/* FIXME: This needs a cache, especially for generic instances, since
* mono_metadata_parse_type () allocates everything from a mempool.
*/
- sig_type = find_cached_memberref_sig (image, cols [MONO_MEMBERREF_SIGNATURE]);
+ sig_type = (MonoType *)find_cached_memberref_sig (image, cols [MONO_MEMBERREF_SIGNATURE]);
if (!sig_type) {
sig_type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr);
if (sig_type == NULL) {
mono_error_set_field_load (error, klass, fname, "Could not parse field '%s' signature %08x", fname, token);
return NULL;
}
- sig_type = cache_memberref_sig (image, cols [MONO_MEMBERREF_SIGNATURE], sig_type);
+ sig_type = (MonoType *)cache_memberref_sig (image, cols [MONO_MEMBERREF_SIGNATURE], sig_type);
}
mono_class_init (klass); /*FIXME is this really necessary?*/
MonoClass *handle_class;
*retklass = NULL;
- result = mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context);
+ result = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context);
// This checks the memberref type as well
if (!result || handle_class != mono_defaults.fieldhandle_class) {
mono_error_set_bad_image (error, image, "Bad field token 0x%08x", token);
return result;
}
- if ((field = mono_conc_hashtable_lookup (image->field_cache, GUINT_TO_POINTER (token)))) {
+ if ((field = (MonoClassField *)mono_conc_hashtable_lookup (image->field_cache, GUINT_TO_POINTER (token)))) {
*retklass = field->parent;
return field;
}
if (!context)
return sig;
- res = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)sig->param_count) * sizeof (MonoType*));
+ res = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)sig->param_count) * sizeof (MonoType*));
res->param_count = sig->param_count;
res->sentinelpos = -1;
res->ret = mono_class_inflate_generic_type_checked (sig->ret, context, error);
{
MonoMethodHeader *res;
int i;
- res = g_malloc0 (MONO_SIZEOF_METHOD_HEADER + sizeof (gpointer) * header->num_locals);
+ res = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER + sizeof (gpointer) * header->num_locals);
res->code = header->code;
res->code_size = header->code_size;
res->max_stack = header->max_stack;
for (i = 0; i < header->num_locals; ++i)
res->locals [i] = mono_class_inflate_generic_type (header->locals [i], context);
if (res->num_clauses) {
- res->clauses = g_memdup (header->clauses, sizeof (MonoExceptionClause) * res->num_clauses);
+ res->clauses = (MonoExceptionClause *)g_memdup (header->clauses, sizeof (MonoExceptionClause) * res->num_clauses);
for (i = 0; i < header->num_clauses; ++i) {
MonoExceptionClause *clause = &res->clauses [i];
if (clause->flags != MONO_EXCEPTION_CLAUSE_NONE)
mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
sig_idx = cols [MONO_MEMBERREF_SIGNATURE];
- sig = find_cached_memberref_sig (image, sig_idx);
+ sig = (MonoMethodSignature *)find_cached_memberref_sig (image, sig_idx);
if (!sig) {
if (!mono_verifier_verify_memberref_method_signature (image, sig_idx, NULL)) {
- guint32 class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
+ guint32 klass = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
const char *fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
//FIXME include the verification error
- mono_error_set_bad_image (error, image, "Bad method signature class token 0x%08x field name %s token 0x%08x", class, fname, token);
+ mono_error_set_bad_image (error, image, "Bad method signature class token 0x%08x field name %s token 0x%08x", klass, fname, token);
return NULL;
}
if (!sig)
return NULL;
- sig = cache_memberref_sig (image, sig_idx, sig);
+ sig = (MonoMethodSignature *)cache_memberref_sig (image, sig_idx, sig);
}
/* FIXME: we probably should verify signature compat in the dynamic case too*/
if (!mono_verifier_is_sig_compatible (image, method, sig)) {
- guint32 class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
+ guint32 klass = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
const char *fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
- mono_error_set_bad_image (error, image, "Incompatible method signature class token 0x%08x field name %s token 0x%08x", class, fname, token);
+ mono_error_set_bad_image (error, image, "Incompatible method signature class token 0x%08x field name %s token 0x%08x", klass, fname, token);
return NULL;
}
}
MonoMethod *method = NULL;
MonoTableInfo *tables = image->tables;
guint32 cols[6];
- guint32 nindex, class, sig_idx;
+ guint32 nindex, class_index, sig_idx;
const char *mname;
MonoMethodSignature *sig;
const char *ptr;
mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, 3);
nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS;
- class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
+ class_index = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
/*g_print ("methodref: 0x%x 0x%x %s\n", class, nindex,
mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));*/
* method into a cache.
*/
if (used_context)
- *used_context = class == MONO_MEMBERREF_PARENT_TYPESPEC;
+ *used_context = class_index == MONO_MEMBERREF_PARENT_TYPESPEC;
- switch (class) {
+ switch (class_index) {
case MONO_MEMBERREF_PARENT_TYPEREF:
klass = mono_class_from_typeref_checked (image, MONO_TOKEN_TYPE_REF | nindex, error);
if (!klass)
return method;
}
default:
- mono_error_set_bad_image (error, image, "Memberref parent unknown: class: %d, index %d", class, nindex);
+ mono_error_set_bad_image (error, image, "Memberref parent unknown: class: %d, index %d", class_index, nindex);
goto fail;
}
ptr = mono_metadata_blob_heap (image, sig_idx);
mono_metadata_decode_blob_size (ptr, &ptr);
- sig = find_cached_memberref_sig (image, sig_idx);
+ sig = (MonoMethodSignature *)find_cached_memberref_sig (image, sig_idx);
if (!sig) {
sig = mono_metadata_parse_method_signature_full (image, NULL, 0, ptr, NULL, error);
if (sig == NULL)
goto fail;
- sig = cache_memberref_sig (image, sig_idx, sig);
+ sig = (MonoMethodSignature *)cache_memberref_sig (image, sig_idx, sig);
}
- switch (class) {
+ switch (class_index) {
case MONO_MEMBERREF_PARENT_TYPEREF:
case MONO_MEMBERREF_PARENT_TYPEDEF:
method = find_method (klass, NULL, mname, sig, klass, error);
break;
}
default:
- mono_error_set_bad_image (error, image,"Memberref parent unknown: class: %d, index %d", class, nindex);
+ mono_error_set_bad_image (error, image,"Memberref parent unknown: class: %d, index %d", class_index, nindex);
goto fail;
}
mono_loader_init ();
if (!assembly) {
- entry = g_malloc0 (sizeof (MonoDllMap));
+ entry = (MonoDllMap *)g_malloc0 (sizeof (MonoDllMap));
entry->dll = dll? g_strdup (dll): NULL;
entry->target = tdll? g_strdup (tdll): NULL;
entry->func = func? g_strdup (func): NULL;
global_dll_map = entry;
global_loader_data_unlock ();
} else {
- entry = mono_image_alloc0 (assembly, sizeof (MonoDllMap));
+ entry = (MonoDllMap *)mono_image_alloc0 (assembly, sizeof (MonoDllMap));
entry->dll = dll? mono_image_strdup (assembly, dll): NULL;
entry->target = tdll? mono_image_strdup (assembly, tdll): NULL;
entry->func = func? mono_image_strdup (assembly, func): NULL;
global_loader_data_lock ();
if (!global_module_map)
global_module_map = g_hash_table_new (g_str_hash, g_str_equal);
- res = g_hash_table_lookup (global_module_map, name);
+ res = (MonoDl *)g_hash_table_lookup (global_module_map, name);
if (res) {
global_loader_data_unlock ();
return res;
if (image_is_dynamic (method->klass->image)) {
MonoReflectionMethodAux *method_aux =
- g_hash_table_lookup (
+ (MonoReflectionMethodAux *)g_hash_table_lookup (
((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (!method_aux)
return NULL;
image->pinvoke_scopes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
image->pinvoke_scope_filenames = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
}
- module = g_hash_table_lookup (image->pinvoke_scopes, new_scope);
- found_name = g_hash_table_lookup (image->pinvoke_scope_filenames, new_scope);
+ module = (MonoDl *)g_hash_table_lookup (image->pinvoke_scopes, new_scope);
+ found_name = (char *)g_hash_table_lookup (image->pinvoke_scope_filenames, new_scope);
mono_image_unlock (image);
if (module)
cached = TRUE;
if (image_is_dynamic (image)) {
MonoClass *handle_class;
- result = mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context);
+ result = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context);
mono_loader_assert_no_error ();
// This checks the memberref type as well
if (mono_metadata_token_table (token) == MONO_TABLE_METHOD) {
if (!image->method_cache)
image->method_cache = g_hash_table_new (NULL, NULL);
- result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
+ result = (MonoMethod *)g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
} else if (!image_is_dynamic (image)) {
if (!image->methodref_cache)
image->methodref_cache = g_hash_table_new (NULL, NULL);
- result = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
+ result = (MonoMethod *)g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
}
mono_image_unlock (image);
MonoMethod *result2 = NULL;
if (mono_metadata_token_table (token) == MONO_TABLE_METHOD)
- result2 = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
+ result2 = (MonoMethod *)g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
else if (!image_is_dynamic (image))
- result2 = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
+ result2 = (MonoMethod *)g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
if (result2) {
mono_image_unlock (image);
if (image_is_dynamic (klass->image)) {
MonoReflectionMethodAux *method_aux =
- g_hash_table_lookup (
+ (MonoReflectionMethodAux *)g_hash_table_lookup (
((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (method_aux && method_aux->param_names) {
for (i = 0; i < mono_method_signature (method)->param_count; ++i)
mono_image_lock (klass->image);
if (klass->image->wrapper_param_names)
- pnames = g_hash_table_lookup (klass->image->wrapper_param_names, method);
+ pnames = (char **)g_hash_table_lookup (klass->image->wrapper_param_names, method);
mono_image_unlock (klass->image);
if (pnames) {
if (image_is_dynamic (method->klass->image)) {
MonoReflectionMethodAux *method_aux =
- g_hash_table_lookup (
+ (MonoReflectionMethodAux *)g_hash_table_lookup (
((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (method_aux && method_aux->param_marshall) {
MonoMarshalSpec **dyn_specs = method_aux->param_marshall;
if (image_is_dynamic (method->klass->image)) {
MonoReflectionMethodAux *method_aux =
- g_hash_table_lookup (
+ (MonoReflectionMethodAux *)g_hash_table_lookup (
((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
MonoMarshalSpec **dyn_specs = method_aux->param_marshall;
if (dyn_specs) {
if (method->is_inflated)
method = ((MonoMethodInflated *) method)->declaring;
- data = ((MonoMethodWrapper *)method)->method_data;
+ data = (void **)((MonoMethodWrapper *)method)->method_data;
g_assert (data != NULL);
g_assert (id <= GPOINTER_TO_UINT (*data));
return data [id];
static gboolean
stack_walk_adapter (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
- StackWalkUserData *d = data;
+ StackWalkUserData *d = (StackWalkUserData *)data;
switch (frame->type) {
case FRAME_TYPE_DEBUGGER_INVOKE:
static gboolean
async_stack_walk_adapter (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
- AsyncStackWalkUserData *d = data;
+ AsyncStackWalkUserData *d = (AsyncStackWalkUserData *)data;
switch (frame->type) {
case FRAME_TYPE_DEBUGGER_INVOKE:
static gboolean
last_managed (MonoMethod *m, gint no, gint ilo, gboolean managed, gpointer data)
{
- MonoMethod **dest = data;
+ MonoMethod **dest = (MonoMethod **)data;
*dest = m;
/*g_print ("In %s::%s [%d] [%d]\n", m->klass->name, m->name, no, ilo);*/
if (can_cache_signature) {
mono_image_lock (img);
- signature = g_hash_table_lookup (img->method_signatures, sig);
+ signature = (MonoMethodSignature *)g_hash_table_lookup (img->method_signatures, sig);
mono_image_unlock (img);
}
if (can_cache_signature) {
mono_image_lock (img);
- sig2 = g_hash_table_lookup (img->method_signatures, sig);
+ sig2 = (MonoMethodSignature *)g_hash_table_lookup (img->method_signatures, sig);
if (!sig2)
g_hash_table_insert (img->method_signatures, (gpointer)sig, signature);
mono_image_unlock (img);
if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)
signature->pinvoke = 1;
else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
- MonoCallConvention conv = 0;
+ MonoCallConvention conv = (MonoCallConvention)0;
MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)m;
signature->pinvoke = 1;
container = mono_method_get_generic_container (method);
if (!container)
container = method->klass->generic_container;
- header = mono_metadata_parse_mh_full (img, container, loc);
+ header = mono_metadata_parse_mh_full (img, container, (const char *)loc);
return header;
}
static int
culture_lcid_locator (const void *a, const void *b)
{
- const int *lcid = a;
- const CultureInfoEntry *bb = b;
+ const int *lcid = (const int *)a;
+ const CultureInfoEntry *bb = (const CultureInfoEntry *)b;
return *lcid - bb->lcid;
}
static int
culture_name_locator (const void *a, const void *b)
{
- const char *aa = a;
- const CultureInfoNameEntry *bb = b;
+ const char *aa = (const char *)a;
+ const CultureInfoNameEntry *bb = (const CultureInfoNameEntry *)b;
int ret;
ret = strcmp (aa, idx2string (bb->name));
static int
region_name_locator (const void *a, const void *b)
{
- const char *aa = a;
- const RegionInfoNameEntry *bb = b;
+ const char *aa = (const char *)a;
+ const RegionInfoNameEntry *bb = (const RegionInfoNameEntry *)b;
int ret;
ret = strcmp (aa, idx2string (bb->name));
char *n;
n = mono_string_to_utf8 (name);
- ne = mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
+ ne = (const CultureInfoNameEntry *)mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
sizeof (CultureInfoNameEntry), culture_name_locator);
g_free (n);
if (ne == NULL) {
{
const CultureInfoEntry *ci;
- ci = mono_binary_search (&lcid, culture_entries, NUM_CULTURE_ENTRIES, sizeof (CultureInfoEntry), culture_lcid_locator);
+ ci = (const CultureInfoEntry *)mono_binary_search (&lcid, culture_entries, NUM_CULTURE_ENTRIES, sizeof (CultureInfoEntry), culture_lcid_locator);
return ci;
}
const RegionInfoEntry *entry;
const CultureInfoEntry *ne;
- ne = mono_binary_search (&lcid, culture_entries, NUM_CULTURE_ENTRIES, sizeof (CultureInfoEntry), culture_lcid_locator);
+ ne = (const CultureInfoEntry *)mono_binary_search (&lcid, culture_entries, NUM_CULTURE_ENTRIES, sizeof (CultureInfoEntry), culture_lcid_locator);
if (ne == NULL)
return FALSE;
char *n;
n = mono_string_to_utf8 (name);
- ne = mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
+ ne = (const CultureInfoNameEntry *)mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
sizeof (CultureInfoNameEntry), culture_name_locator);
if (ne == NULL) {
char *n;
n = mono_string_to_utf8 (name);
- ne = mono_binary_search (n, region_name_entries, NUM_REGION_ENTRIES,
+ ne = (const RegionInfoNameEntry *)mono_binary_search (n, region_name_entries, NUM_REGION_ENTRIES,
sizeof (RegionInfoNameEntry), region_name_locator);
if (ne == NULL) {
return(0x007F);
}
-MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this_obj, MonoString *old, MonoString *new, MonoCompareInfo *comp)
+MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this_obj, MonoString *old, MonoString *new_, MonoCompareInfo *comp)
{
/* Do a normal ascii string compare and replace, as we only
* know the invariant locale if we dont have ICU
*/
- return(string_invariant_replace (this_obj, old, new));
+ return(string_invariant_replace (this_obj, old, new_));
}
static gint32 string_invariant_compare_char (gunichar2 c1, gunichar2 c2,
else
d = NULL;
} else {
- d = g_hash_table_lookup (delegate_hash_table, ftn);
+ d = (MonoDelegate *)g_hash_table_lookup (delegate_hash_table, ftn);
mono_marshal_unlock ();
}
if (d == NULL) {
void **method_data;
MonoMethod *method;
- ji = mono_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (ptr));
+ ji = mono_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (ptr));
g_assert (ji);
method = mono_jit_info_get_method (ji);
- method_data = ((MonoMethodWrapper*)method)->method_data;
+ method_data = (void **)((MonoMethodWrapper*)method)->method_data;
/*the target gchandle is the first entry after size and the wrapper itself.*/
gchandle = GPOINTER_TO_UINT (method_data [2]);
break;
case MONO_TYPE_CLASS:
nativeArraySize = array->max_length;
- nativeArray = malloc(sizeof(gpointer) * nativeArraySize);
+ nativeArray = (void **)malloc(sizeof(gpointer) * nativeArraySize);
for(i = 0; i < nativeArraySize; ++i)
- nativeArray[i] = ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal(((gpointer*)array->vector)[i]);
+ nativeArray[i] = ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal(((MonoObject **)array->vector)[i]);
return nativeArray;
case MONO_TYPE_U1:
case MONO_TYPE_BOOLEAN:
guint16 *ut;
glong items_written;
- ut = g_utf8_to_utf16 (native_arr, elnum, NULL, &items_written, &error);
+ ut = g_utf8_to_utf16 ((const gchar *)native_arr, elnum, NULL, &items_written, &error);
if (!error) {
memcpy (mono_array_addr (arr, guint16, 0), ut, items_written * sizeof (guint16));
return NULL;
} else {
guint len = mono_string_builder_capacity (sb) + 1;
- gchar *res = mono_marshal_alloc (len * sizeof (gchar));
+ gchar *res = (gchar *)mono_marshal_alloc (len * sizeof (gchar));
g_assert (str_len < len);
memcpy (res, tmp, str_len * sizeof (gchar));
res[str_len] = '\0';
if (len == 0)
len = 1;
- gunichar2 *str = mono_marshal_alloc ((len + 1) * sizeof (gunichar2));
+ gunichar2 *str = (gunichar2 *)mono_marshal_alloc ((len + 1) * sizeof (gunichar2));
str[len] = '\0';
if (len == 0)
if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
- ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE, klass->unicode, &conv);
+ ntype = (MonoMarshalNative)mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE, klass->unicode, &conv);
if (last_field) {
msize = klass->instance_size - info->fields [i].field->offset;
static void
emit_struct_conv (MonoMethodBuilder *mb, MonoClass *klass, gboolean to_object)
{
- emit_struct_conv_full (mb, klass, to_object, -1);
+ emit_struct_conv_full (mb, klass, to_object, (MonoMarshalNative)-1);
}
static void
case MONO_NATIVE_BSTR:
return MONO_MARSHAL_CONV_STR_BSTR;
default:
- return -1;
+ return (MonoMarshalConv)-1;
}
}
return MONO_MARSHAL_CONV_SB_LPTSTR;
break;
default:
- return -1;
+ return (MonoMarshalConv)-1;
}
}
case MONO_NATIVE_BSTR:
return MONO_MARSHAL_CONV_BSTR_STR;
default:
- return -1;
+ return (MonoMarshalConv)-1;
}
}
return MONO_MARSHAL_CONV_LPTSTR_SB;
break;
default:
- return -1;
+ return (MonoMarshalConv)-1;
}
}
MonoMethod *res;
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, key);
+ res = (MonoMethod *)g_hash_table_lookup (cache, key);
mono_marshal_unlock ();
return res;
}
*out_found = FALSE;
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, key);
+ res = (MonoMethod *)g_hash_table_lookup (cache, key);
mono_marshal_unlock ();
if (!res) {
MonoMethod *newm;
newm = mono_mb_create_method (mb, sig, max_stack);
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, key);
+ res = (MonoMethod *)g_hash_table_lookup (cache, key);
if (!res) {
res = newm;
g_hash_table_insert (cache, key, res);
{
g_assert (wrapper->wrapper_type);
- return mono_method_get_wrapper_data (wrapper, 1);
+ return (WrapperInfo *)mono_method_get_wrapper_data (wrapper, 1);
}
/*
if (method->wrapper_type == MONO_WRAPPER_NONE || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
return;
- datav = ((MonoMethodWrapper *)method)->method_data;
+ datav = (void **)((MonoMethodWrapper *)method)->method_data;
datav [1] = info;
}
{
WrapperInfo *info;
- info = mono_image_alloc0 (mb->method->klass->image, sizeof (WrapperInfo));
+ info = (WrapperInfo *)mono_image_alloc0 (mb->method->klass->image, sizeof (WrapperInfo));
info->subtype = subtype;
return info;
}
/* Cache it */
mono_memory_barrier ();
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, key);
+ res = (MonoMethod *)g_hash_table_lookup (cache, key);
if (!res) {
g_hash_table_insert (cache, key, inst);
res = inst;
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
mono_memory_barrier ();
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, key);
+ res = (MonoMethod *)g_hash_table_lookup (cache, key);
if (!res) {
g_hash_table_insert (cache, key, inst);
res = inst;
/* Cache it */
mono_memory_barrier ();
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, orig_method->klass);
+ res = (MonoMethod *)g_hash_table_lookup (cache, orig_method->klass);
if (!res) {
g_hash_table_insert (cache, orig_method->klass, inst);
res = inst;
mono_memory_barrier ();
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, orig_method->klass);
+ res = (MonoMethod *)g_hash_table_lookup (cache, orig_method->klass);
if (!res) {
g_hash_table_insert (cache, orig_method->klass, inst);
res = inst;
msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
- ares = mono_array_get (msg->args, gpointer, sig->param_count - 1);
+ ares = (MonoAsyncResult *)mono_array_get (msg->args, gpointer, sig->param_count - 1);
if (ares == NULL) {
mono_raise_exception (mono_exception_from_name_msg (mono_defaults.corlib, "System.Runtime.Remoting", "RemotingException", "The async result object is null or of an unexpected type."));
return NULL;
MonoMethodSignature *res;
int i;
- res = g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
+ res = (MonoMethodSignature *)g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
memcpy (res, sig, MONO_SIZEOF_METHOD_SIGNATURE);
res->param_count = sig->param_count + 1;
for (i = 0; i < sig->param_count; ++i)
cache = *cache_ptr;
key.sig = invoke_sig;
key.pointer = target_method;
- res = g_hash_table_lookup (cache, &key);
+ res = (MonoMethod *)g_hash_table_lookup (cache, &key);
mono_marshal_unlock ();
if (res)
return res;
mono_marshal_lock ();
callsig = NULL;
for (item = strsig_list; item; item = item->next) {
- cs = item->data;
+ cs = (CtorSigPair *)item->data;
/* mono_metadata_signature_equal () is safe to call with the marshal lock
* because it is lock-free.
*/
emit_invoke_call (MonoMethodBuilder *mb, MonoMethod *method,
MonoMethodSignature *sig, MonoMethodSignature *callsig,
int loc_res,
- gboolean virtual, gboolean need_direct_wrapper)
+ gboolean virtual_, gboolean need_direct_wrapper)
{
static MonoString *string_dummy = NULL;
int i;
string_dummy = mono_string_new_wrapper ("dummy");
}
- if (virtual) {
+ if (virtual_) {
g_assert (sig->hasthis);
g_assert (method->flags & METHOD_ATTRIBUTE_VIRTUAL);
}
}
}
- if (virtual) {
+ if (virtual_) {
mono_mb_emit_op (mb, CEE_CALLVIRT, method);
} else if (need_direct_wrapper) {
mono_mb_emit_op (mb, CEE_CALL, method);
static void
emit_runtime_invoke_body (MonoMethodBuilder *mb, MonoClass *target_klass, MonoMethod *method,
MonoMethodSignature *sig, MonoMethodSignature *callsig,
- gboolean virtual, gboolean need_direct_wrapper)
+ gboolean virtual_, gboolean need_direct_wrapper)
{
gint32 labels [16];
MonoExceptionClause *clause;
*/
labels [1] = mono_mb_get_label (mb);
emit_thread_force_interrupt_checkpoint (mb);
- emit_invoke_call (mb, method, sig, callsig, loc_res, virtual, need_direct_wrapper);
+ emit_invoke_call (mb, method, sig, callsig, loc_res, virtual_, need_direct_wrapper);
labels [2] = mono_mb_emit_branch (mb, CEE_LEAVE);
/* Add a try clause around the call */
- clause = mono_image_alloc0 (target_klass->image, sizeof (MonoExceptionClause));
+ clause = (MonoExceptionClause *)mono_image_alloc0 (target_klass->image, sizeof (MonoExceptionClause));
clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
clause->data.catch_class = mono_defaults.exception_class;
clause->try_offset = labels [1];
*/
mono_mb_patch_branch (mb, labels [0]);
emit_thread_force_interrupt_checkpoint (mb);
- emit_invoke_call (mb, method, sig, callsig, loc_res, virtual, need_direct_wrapper);
+ emit_invoke_call (mb, method, sig, callsig, loc_res, virtual_, need_direct_wrapper);
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_RET);
* first argument (after 'this').
*/
MonoMethod *
-mono_marshal_get_runtime_invoke (MonoMethod *method, gboolean virtual, gboolean pass_rgctx)
+mono_marshal_get_runtime_invoke (MonoMethod *method, gboolean virtual_, gboolean pass_rgctx)
{
MonoMethodSignature *sig, *csig, *callsig;
MonoMethodBuilder *mb;
finalize_signature->hasthis = 1;
}
- if (virtual)
+ if (virtual_)
need_direct_wrapper = TRUE;
/*
* Use a separate cache indexed by methods to speed things up and to avoid the
* boundless mempool growth caused by the signature_dup stuff below.
*/
- if (virtual)
+ if (virtual_)
cache = get_cache (&method->klass->image->runtime_invoke_vcall_cache, mono_aligned_addr_hash, NULL);
else
cache = get_cache (&mono_method_get_wrapper_cache (method)->runtime_invoke_direct_cache, mono_aligned_addr_hash, NULL);
/* from mono_marshal_find_in_cache */
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, callsig);
+ res = (MonoMethod *)g_hash_table_lookup (cache, callsig);
mono_marshal_unlock ();
if (res) {
csig->call_convention = MONO_CALL_C;
#endif
- name = mono_signature_to_name (callsig, pass_rgctx ? (virtual ? "runtime_invoke_virtual_rgctx" : "runtime_invoke_rgctx") : (virtual ? "runtime_invoke_virtual" : "runtime_invoke"));
+ name = mono_signature_to_name (callsig, pass_rgctx ? (virtual_ ? "runtime_invoke_virtual_rgctx" : "runtime_invoke_rgctx") : (virtual_ ? "runtime_invoke_virtual" : "runtime_invoke"));
mb = mono_mb_new (target_klass, name, MONO_WRAPPER_RUNTIME_INVOKE);
g_free (name);
param_names [3] = "method";
mono_mb_set_param_names (mb, param_names);
- emit_runtime_invoke_body (mb, target_klass, method, sig, callsig, virtual, need_direct_wrapper);
+ emit_runtime_invoke_body (mb, target_klass, method, sig, callsig, virtual_, need_direct_wrapper);
#endif
if (need_direct_wrapper) {
#ifndef DISABLE_JIT
mb->skip_visibility = 1;
#endif
- info = mono_wrapper_info_create (mb, virtual ? WRAPPER_SUBTYPE_RUNTIME_INVOKE_VIRTUAL : WRAPPER_SUBTYPE_RUNTIME_INVOKE_DIRECT);
+ info = mono_wrapper_info_create (mb, virtual_ ? WRAPPER_SUBTYPE_RUNTIME_INVOKE_VIRTUAL : WRAPPER_SUBTYPE_RUNTIME_INVOKE_DIRECT);
info->d.runtime_invoke.method = method;
res = mono_mb_create_and_cache_full (cache, method, mb, csig, sig->param_count + 16, info, NULL);
} else {
/* taken from mono_mb_create_and_cache */
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, callsig);
+ res = (MonoMethod *)g_hash_table_lookup (cache, callsig);
mono_marshal_unlock ();
info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_RUNTIME_INVOKE_NORMAL);
newm = mono_mb_create (mb, csig, sig->param_count + 16, info);
mono_marshal_lock ();
- res = g_hash_table_lookup (cache, callsig);
+ res = (MonoMethod *)g_hash_table_lookup (cache, callsig);
if (!res) {
GHashTable *direct_cache;
res = newm;
pos = mono_mb_emit_branch (mb, CEE_LEAVE);
- clause = mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
+ clause = (MonoExceptionClause *)mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
clause->flags = MONO_EXCEPTION_CLAUSE_FILTER;
clause->try_len = mono_mb_get_label (mb);
conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
}
else
- conv = -1;
+ conv = (MonoMarshalConv)-1;
if (is_string && conv == -1) {
char *msg = g_strdup_printf ("string/stringbuilder marshalling conversion %d not implemented", encoding);
mono_mb_emit_stloc (mb, 1);
/* emit valuetype conversion code */
- emit_struct_conv_full (mb, eklass, FALSE, eklass == mono_defaults.char_class ? encoding : -1);
+ emit_struct_conv_full (mb, eklass, FALSE, eklass == mono_defaults.char_class ? encoding : (MonoMarshalNative)-1);
}
mono_mb_emit_add_to_local (mb, index_var, 1);
mono_mb_emit_stloc (mb, 1);
/* emit valuetype conversion code */
- emit_struct_conv_full (mb, eklass, TRUE, eklass == mono_defaults.char_class ? encoding : -1);
+ emit_struct_conv_full (mb, eklass, TRUE, eklass == mono_defaults.char_class ? encoding : (MonoMarshalNative)-1);
}
if (need_free) {
conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
}
else
- conv = -1;
+ conv = (MonoMarshalConv)-1;
mono_marshal_load_type_info (eklass);
conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
}
else
- conv = -1;
+ conv = (MonoMarshalConv)-1;
mono_marshal_load_type_info (eklass);
MonoClass *eklass;
guint32 label1, label2, label3;
int index_var, src, dest, esize;
- MonoMarshalConv conv = -1;
+ MonoMarshalConv conv = (MonoMarshalConv)-1;
gboolean is_string = FALSE;
g_assert (!t->byref);
}
/* we first do all conversions */
- tmp_locals = alloca (sizeof (int) * sig->param_count);
- m.orig_conv_args = alloca (sizeof (int) * (sig->param_count + 1));
+ tmp_locals = (int *)alloca (sizeof (int) * sig->param_count);
+ m.orig_conv_args = (int *)alloca (sizeof (int) * (sig->param_count + 1));
for (i = 0; i < sig->param_count; i ++) {
tmp_locals [i] = emit_marshal (&m, i + param_shift, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_CONV_IN);
}
/* we first do all conversions */
- tmp_locals = alloca (sizeof (int) * sig->param_count);
+ tmp_locals = (int *)alloca (sizeof (int) * sig->param_count);
for (i = 0; i < sig->param_count; i ++) {
MonoType *t = sig->params [i];
this_local = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
taken_local = mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
- clause = mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
+ clause = (MonoExceptionClause *)mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
clause->flags = MONO_EXCEPTION_CLAUSE_FINALLY;
#endif
int i;
*nwrappers = STELEMREF_KIND_COUNT;
- res = g_malloc0 (STELEMREF_KIND_COUNT * sizeof (MonoMethod*));
+ res = (MonoMethod **)g_malloc0 (STELEMREF_KIND_COUNT * sizeof (MonoMethod*));
for (i = 0; i < STELEMREF_KIND_COUNT; ++i)
res [i] = get_virtual_stelemref_wrapper (i);
return res;
if (s == NULL) {
return NULL;
} else {
- gunichar2 *res = mono_marshal_alloc ((mono_string_length (s) * 2) + 2);
+ gunichar2 *res = (gunichar2 *)mono_marshal_alloc ((mono_string_length (s) * 2) + 2);
memcpy (res, mono_string_chars (s), mono_string_length (s) * 2);
res [mono_string_length (s)] = 0;
return res;
gunichar2 *res = ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal
((mono_string_length (string) + 1) * 2);
#else
- gunichar2 *res = g_malloc ((mono_string_length (string) + 1) * 2);
+ gunichar2 *res = (gunichar2 *)g_malloc ((mono_string_length (string) + 1) * 2);
#endif
memcpy (res, mono_string_chars (string), mono_string_length (string) * 2);
res [mono_string_length (string)] = 0;
static gboolean
mono_marshal_is_loading_type_info (MonoClass *klass)
{
- GSList *loads_list = mono_native_tls_get_value (load_type_info_tls_id);
+ GSList *loads_list = (GSList *)mono_native_tls_get_value (load_type_info_tls_id);
return g_slist_find (loads_list, klass) != NULL;
}
* under initialization in a TLS list.
*/
g_assert (!mono_marshal_is_loading_type_info (klass));
- loads_list = mono_native_tls_get_value (load_type_info_tls_id);
+ loads_list = (GSList *)mono_native_tls_get_value (load_type_info_tls_id);
loads_list = g_slist_prepend (loads_list, klass);
mono_native_tls_set_value (load_type_info_tls_id, loads_list);
layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
/* The mempool is protected by the loader lock */
- info = mono_image_alloc0 (klass->image, MONO_SIZEOF_MARSHAL_TYPE + sizeof (MonoMarshalField) * count);
+ info = (MonoMarshalType *)mono_image_alloc0 (klass->image, MONO_SIZEOF_MARSHAL_TYPE + sizeof (MonoMarshalField) * count);
info->num_fields = count;
/* Try to find a size for this type in metadata */
mono_marshal_load_type_info (klass->element_class);
}
- loads_list = mono_native_tls_get_value (load_type_info_tls_id);
+ loads_list = (GSList *)mono_native_tls_get_value (load_type_info_tls_id);
loads_list = g_slist_remove (loads_list, klass);
mono_native_tls_set_value (load_type_info_tls_id, loads_list);
}
if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
- mono_struct_delete_old (klass, ptr);
+ mono_struct_delete_old (klass, (char *)ptr);
}
mono_marshal_free (ptr);
}
/* try */
- clause = mono_image_alloc0 (image, sizeof (MonoExceptionClause));
+ clause = (MonoExceptionClause *)mono_image_alloc0 (image, sizeof (MonoExceptionClause));
clause->try_offset = mono_mb_get_label (mb);
/* push method's args */
initial_size = MONO_MEMPOOL_MINSIZE;
#endif
- pool = g_malloc (initial_size);
+ pool = (MonoMemPool *)g_malloc (initial_size);
pool->next = NULL;
pool->pos = (guint8*)pool + SIZEOF_MEM_POOL; // Start after header
// (In individual allocation mode, the constant will be 0 and this path will always be taken)
if (size >= MONO_MEMPOOL_PREFER_INDIVIDUAL_ALLOCATION_SIZE) {
guint new_size = SIZEOF_MEM_POOL + size;
- MonoMemPool *np = g_malloc (new_size);
+ MonoMemPool *np = (MonoMemPool *)g_malloc (new_size);
np->next = pool->next;
np->size = new_size;
} else {
// Notice: any unused memory at the end of the old head becomes simply abandoned in this case until the mempool is freed (see Bugzilla #35136)
guint new_size = get_next_size (pool, size);
- MonoMemPool *np = g_malloc (new_size);
+ MonoMemPool *np = (MonoMemPool *)g_malloc (new_size);
np->next = pool->next;
np->size = new_size;
return NULL;
l = strlen (s);
- res = mono_mempool_alloc (pool, l + 1);
+ res = (char *)mono_mempool_alloc (pool, l + 1);
memcpy (res, s, l + 1);
return res;
return FALSE;
if (ctx->stage > STAGE_PE) {
- MonoCLIImageInfo *iinfo = ctx->image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)ctx->image->image_info;
const int top = iinfo->cli_section_count;
MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
static DataDirectory
get_data_dir (VerifyContext *ctx, int idx)
{
- MonoCLIImageInfo *iinfo = ctx->image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)ctx->image->image_info;
MonoPEDirEntry *entry= &iinfo->cli_header.datadir.pe_export_table;
DataDirectory res;
base = tinfo->base;
VERIFIER_DEBUG ( printf ("looking token %x table %d col %d rsize %d roff %d\n", coded_token, table, column, locator.col_size, locator.col_offset) );
- res = mono_binary_search (&locator, base, tinfo->rows, tinfo->row_size, token_locator);
+ res = (const char *)mono_binary_search (&locator, base, tinfo->rows, tinfo->row_size, token_locator);
if (!res)
return -1;
return NULL;
}
- enum_name = g_memdup (str_start, str_len + 1);
+ enum_name = (char *)g_memdup (str_start, str_len + 1);
enum_name [str_len] = 0;
type = mono_reflection_type_from_name (enum_name, ctx->image);
if (!type) {
} else if (etype == 0x50 || etype == MONO_TYPE_CLASS) {
klass = mono_defaults.systemtype_class;
} else if ((etype >= MONO_TYPE_BOOLEAN && etype <= MONO_TYPE_STRING) || etype == 0x51) {
- simple_type.type = etype == 0x51 ? MONO_TYPE_OBJECT : etype;
+ simple_type.type = etype == 0x51 ? MONO_TYPE_OBJECT : (MonoTypeEnum)etype;
klass = mono_class_from_mono_type (&simple_type);
} else
FAIL (ctx, g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype));
FAIL (ctx, g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d type", i));
if (kind >= MONO_TYPE_BOOLEAN && kind <= MONO_TYPE_STRING) {
- simple_type.type = kind;
+ simple_type.type = (MonoTypeEnum)kind;
type = &simple_type;
} else if (kind == MONO_TYPE_ENUM) {
MonoClass *klass = get_enum_by_encoded_name (ctx, &ptr, end);
} else if (etype == 0x50 || etype == MONO_TYPE_CLASS) {
klass = mono_defaults.systemtype_class;
} else if ((etype >= MONO_TYPE_BOOLEAN && etype <= MONO_TYPE_STRING) || etype == 0x51) {
- simple_type.type = etype == 0x51 ? MONO_TYPE_OBJECT : etype;
+ simple_type.type = etype == 0x51 ? MONO_TYPE_OBJECT : (MonoTypeEnum)etype;
klass = mono_class_from_mono_type (&simple_type);
} else
FAIL (ctx, g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype));
static void
verify_manifest_resource_table (VerifyContext *ctx)
{
- MonoCLIImageInfo *iinfo = ctx->image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)ctx->image->image_info;
MonoCLIHeader *ch = &iinfo->cli_cli_header;
MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_MANIFESTRESOURCE];
guint32 data [MONO_MANIFEST_SIZE], impl_table, token, resources_size;
static guint
typedef_hash (gconstpointer _key)
{
- const TypeDefUniqueId *key = _key;
+ const TypeDefUniqueId *key = (const TypeDefUniqueId *)_key;
return g_str_hash (key->name) ^ g_str_hash (key->name_space) ^ key->resolution_scope; /*XXX better salt the int key*/
}
static gboolean
typedef_equals (gconstpointer _a, gconstpointer _b)
{
- const TypeDefUniqueId *a = _a;
- const TypeDefUniqueId *b = _b;
+ const TypeDefUniqueId *a = (const TypeDefUniqueId *)_a;
+ const TypeDefUniqueId *b = (const TypeDefUniqueId *)_b;
return !strcmp (a->name, b->name) && !strcmp (a->name_space, b->name_space) && a->resolution_scope == b->resolution_scope;
}
{
g_free (ctx->sections);
if (ctx->errors) {
- MonoVerifyInfo *info = ctx->errors->data;
+ MonoVerifyInfo *info = (MonoVerifyInfo *)ctx->errors->data;
mono_error_set_bad_image (error, ctx->image, "%s", info->message);
mono_free_verify_list (ctx->errors);
}
if (!etype)
return NULL;
- array = transient ? g_malloc0 (sizeof (MonoArrayType)) : mono_image_alloc0 (m, sizeof (MonoArrayType));
+ array = transient ? (MonoArrayType *)g_malloc0 (sizeof (MonoArrayType)) : (MonoArrayType *)mono_image_alloc0 (m, sizeof (MonoArrayType));
array->eklass = mono_class_from_mono_type (etype);
array->rank = mono_metadata_decode_value (ptr, &ptr);
array->numsizes = mono_metadata_decode_value (ptr, &ptr);
if (array->numsizes)
- array->sizes = transient ? g_malloc0 (sizeof (int) * array->numsizes) : mono_image_alloc0 (m, sizeof (int) * array->numsizes);
+ array->sizes = transient ? (int *)g_malloc0 (sizeof (int) * array->numsizes) : (int *)mono_image_alloc0 (m, sizeof (int) * array->numsizes);
for (i = 0; i < array->numsizes; ++i)
array->sizes [i] = mono_metadata_decode_value (ptr, &ptr);
array->numlobounds = mono_metadata_decode_value (ptr, &ptr);
if (array->numlobounds)
- array->lobounds = transient ? g_malloc0 (sizeof (int) * array->numlobounds) : mono_image_alloc0 (m, sizeof (int) * array->numlobounds);
+ array->lobounds = transient ? (int *)g_malloc0 (sizeof (int) * array->numlobounds) : (int *)mono_image_alloc0 (m, sizeof (int) * array->numlobounds);
for (i = 0; i < array->numlobounds; ++i)
array->lobounds [i] = mono_metadata_decode_signed_value (ptr, &ptr);
int size;
size = MONO_SIZEOF_TYPE + ((gint32)count) * sizeof (MonoCustomMod);
- type = transient ? g_malloc0 (size) : mono_image_alloc0 (m, size);
+ type = transient ? (MonoType *)g_malloc0 (size) : (MonoType *)mono_image_alloc0 (m, size);
type->num_mods = count;
if (count > 64)
g_warning ("got more than 64 modifiers in type");
}
}
/* No need to use locking since nobody is modifying the hash table */
- if ((cached = g_hash_table_lookup (type_cache, type))) {
+ if ((cached = (MonoType *)g_hash_table_lookup (type_cache, type))) {
return cached;
}
}
/* printf ("%x %x %c %s\n", type->attrs, type->num_mods, type->pinned ? 'p' : ' ', mono_type_full_name (type)); */
if (type == &stype) { // Type was allocated on the stack, so we need to copy it to safety
- type = transient ? g_malloc (MONO_SIZEOF_TYPE) : mono_image_alloc (m, MONO_SIZEOF_TYPE);
+ type = transient ? (MonoType *)g_malloc (MONO_SIZEOF_TYPE) : (MonoType *)mono_image_alloc (m, MONO_SIZEOF_TYPE);
memcpy (type, &stype, MONO_SIZEOF_TYPE);
}
return type;
const char *ptr;
if (image_is_dynamic (image))
- return mono_lookup_dynamic_token (image, token, NULL);
+ return (MonoMethodSignature *)mono_lookup_dynamic_token (image, token, NULL);
g_assert (mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG);
{
MonoMethodSignature *sig;
- sig = mono_image_alloc0 (m, MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)nparams) * sizeof (MonoType*));
+ sig = (MonoMethodSignature *)mono_image_alloc0 (m, MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)nparams) * sizeof (MonoType*));
sig->param_count = nparams;
sig->sentinelpos = -1;
sigsize += MONO_SIZEOF_TYPE;
if (image) {
- ret = mono_image_alloc (image, sigsize);
+ ret = (MonoMethodSignature *)mono_image_alloc (image, sigsize);
} else if (mp) {
- ret = mono_mempool_alloc (mp, sigsize);
+ ret = (MonoMethodSignature *)mono_mempool_alloc (mp, sigsize);
} else {
- ret = g_malloc (sigsize);
+ ret = (MonoMethodSignature *)g_malloc (sigsize);
}
memcpy (ret, sig, sig_header_size - padding);
static gboolean
inflated_method_equal (gconstpointer a, gconstpointer b)
{
- const MonoMethodInflated *ma = a;
- const MonoMethodInflated *mb = b;
+ const MonoMethodInflated *ma = (const MonoMethodInflated *)a;
+ const MonoMethodInflated *mb = (const MonoMethodInflated *)b;
if (ma->declaring != mb->declaring)
return FALSE;
return mono_metadata_generic_context_equal (&ma->context, &mb->context);
static guint
inflated_method_hash (gconstpointer a)
{
- const MonoMethodInflated *ma = a;
+ const MonoMethodInflated *ma = (const MonoMethodInflated *)a;
return (mono_metadata_generic_context_hash (&ma->context) ^ mono_aligned_addr_hash (ma->declaring));
}
static gboolean
inflated_signature_equal (gconstpointer a, gconstpointer b)
{
- const MonoInflatedMethodSignature *sig1 = a;
- const MonoInflatedMethodSignature *sig2 = b;
+ const MonoInflatedMethodSignature *sig1 = (const MonoInflatedMethodSignature *)a;
+ const MonoInflatedMethodSignature *sig2 = (const MonoInflatedMethodSignature *)b;
/* sig->sig is assumed to be canonized */
if (sig1->sig != sig2->sig)
static guint
inflated_signature_hash (gconstpointer a)
{
- const MonoInflatedMethodSignature *sig = a;
+ const MonoInflatedMethodSignature *sig = (const MonoInflatedMethodSignature *)a;
/* sig->sig is assumed to be canonized */
return mono_metadata_generic_context_hash (&sig->context) ^ mono_aligned_addr_hash (sig->sig);
set = NULL;
while (l) // Iterate over selected list, looking for an imageset with members equal to our target one
{
- set = l->data;
+ set = (MonoImageSet *)l->data;
if (set->nimages == nimages) { // Member count differs, this can't be it
// Compare all members to all members-- order might be different
static gboolean
steal_gclass_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoGenericClass *gclass = key;
- CleanForImageUserData *user_data = data;
+ MonoGenericClass *gclass = (MonoGenericClass *)key;
+ CleanForImageUserData *user_data = (CleanForImageUserData *)data;
g_assert (gclass_in_image (gclass, user_data->image));
static gboolean
steal_ginst_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoGenericInst *ginst = key;
- CleanForImageUserData *user_data = data;
+ MonoGenericInst *ginst = (MonoGenericInst *)key;
+ CleanForImageUserData *user_data = (CleanForImageUserData *)data;
// This doesn't work during corlib compilation
//g_assert (ginst_in_image (ginst, user_data->image));
static gboolean
inflated_method_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoImage *image = data;
- MonoMethodInflated *method = key;
+ MonoImage *image = (MonoImage *)data;
+ MonoMethodInflated *method = (MonoMethodInflated *)key;
// FIXME:
// https://bugzilla.novell.com/show_bug.cgi?id=458168
static gboolean
inflated_signature_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoImage *image = data;
- MonoInflatedMethodSignature *sig = key;
+ MonoImage *image = (MonoImage *)data;
+ MonoInflatedMethodSignature *sig = (MonoInflatedMethodSignature *)key;
return signature_in_image (sig->sig, image) ||
(sig->context.class_inst && ginst_in_image (sig->context.class_inst, image)) ||
static void
check_gmethod (gpointer key, gpointer value, gpointer data)
{
- MonoMethodInflated *method = key;
- MonoImage *image = data;
+ MonoMethodInflated *method = (MonoMethodInflated *)key;
+ MonoImage *image = (MonoImage *)data;
if (method->context.class_inst)
g_assert (!ginst_in_image (method->context.class_inst, image));
return;
for (i = 0; i < image_sets->len; ++i) {
- MonoImageSet *set = g_ptr_array_index (image_sets, i);
+ MonoImageSet *set = (MonoImageSet *)g_ptr_array_index (image_sets, i);
if (!g_slist_find (l, set)) {
g_hash_table_foreach (set->gmethod_cache, check_gmethod, image);
/* Collect the items to delete */
/* delete_image_set () modifies the lists so make a copy */
for (l = image->image_sets; l; l = l->next) {
- MonoImageSet *set = l->data;
+ MonoImageSet *set = (MonoImageSet *)l->data;
mono_image_set_lock (set);
g_hash_table_foreach_steal (set->gclass_cache, steal_gclass_in_image, &gclass_data);
/* Delete the removed items */
for (l = ginst_data.list; l; l = l->next)
- free_generic_inst (l->data);
+ free_generic_inst ((MonoGenericInst *)l->data);
for (l = gclass_data.list; l; l = l->next)
- free_generic_class (l->data);
+ free_generic_class ((MonoGenericClass *)l->data);
g_slist_free (ginst_data.list);
g_slist_free (gclass_data.list);
/* delete_image_set () modifies the lists so make a copy */
set_list = g_slist_copy (image->image_sets);
for (l = set_list; l; l = l->next) {
- MonoImageSet *set = l->data;
+ MonoImageSet *set = (MonoImageSet *)l->data;
delete_image_set (set);
}
mono_image_set_lock (set);
- res = g_hash_table_lookup (set->gsignature_cache, &helper);
+ res = (MonoInflatedMethodSignature *)g_hash_table_lookup (set->gsignature_cache, &helper);
if (!res) {
res = g_new0 (MonoInflatedMethodSignature, 1);
res->sig = sig;
break;
is_open = (i < type_argc);
- ginst = g_alloca (size);
+ ginst = (MonoGenericInst *)g_alloca (size);
memset (ginst, 0, sizeof (MonoGenericInst));
ginst->is_open = is_open;
ginst->type_argc = type_argc;
mono_image_set_lock (set);
- ginst = g_hash_table_lookup (set->ginst_cache, ginst);
+ ginst = (MonoGenericInst *)g_hash_table_lookup (set->ginst_cache, ginst);
if (!ginst) {
- ginst = mono_image_set_alloc0 (set, size);
+ ginst = (MonoGenericInst *)mono_image_set_alloc0 (set, size);
#ifndef MONO_SMALL_CONFIG
ginst->id = ++next_generic_inst_id;
#endif
mono_image_set_lock (set);
- gclass = g_hash_table_lookup (set->gclass_cache, &helper);
+ gclass = (MonoGenericClass *)g_hash_table_lookup (set->gclass_cache, &helper);
/* A tripwire just to keep us honest */
g_assert (!helper.cached_class);
if (!result)
{
// Note this is never deallocated anywhere-- it exists for the lifetime of the image it's allocated from
- result = mono_image_alloc0 (image, sizeof (MonoGenericContainer));
+ result = (MonoGenericContainer *)mono_image_alloc0 (image, sizeof (MonoGenericContainer));
result->owner.image = image;
result->is_anonymous = TRUE;
result->is_small_param = TRUE;
// If another thread already made a container, use that and leak this new one.
// (Technically it would currently be safe to just assign instead of CASing.)
- MonoGenericContainer *exchange = InterlockedCompareExchangePointer ((volatile gpointer *)container_pointer, result, NULL);
+ MonoGenericContainer *exchange = (MonoGenericContainer *)InterlockedCompareExchangePointer ((volatile gpointer *)container_pointer, result, NULL);
if (exchange)
result = exchange;
}
/* Create dummy MonoGenericParam */
MonoGenericParam *param;
- param = mono_image_alloc0 (m, sizeof (MonoGenericParam));
+ param = (MonoGenericParam *)mono_image_alloc0 (m, sizeof (MonoGenericParam));
param->num = index;
param->owner = get_anonymous_container_for_image (m, is_mvar);
MonoType *cached;
/* No need to use locking since nobody is modifying the hash table */
- if ((cached = g_hash_table_lookup (type_cache, type)))
+ if ((cached = (MonoType *)g_hash_table_lookup (type_cache, type)))
return cached;
switch (type->type){
{
mono_error_init (error);
- type->type = mono_metadata_decode_value (ptr, &ptr);
+ type->type = (MonoTypeEnum)mono_metadata_decode_value (ptr, &ptr);
switch (type->type){
case MONO_TYPE_VOID:
int i;
*num_clauses = is_fat ? sect_data_len / 24: sect_data_len / 12;
/* we could just store a pointer if we don't need to byteswap */
- clauses = g_malloc0 (sizeof (MonoExceptionClause) * (*num_clauses));
+ clauses = (MonoExceptionClause *)g_malloc0 (sizeof (MonoExceptionClause) * (*num_clauses));
for (i = 0; i < *num_clauses; ++i) {
MonoExceptionClause *ec = &clauses [i];
guint32 tof_value;
switch (format) {
case METHOD_HEADER_TINY_FORMAT:
- mh = g_malloc0 (MONO_SIZEOF_METHOD_HEADER);
+ mh = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER);
ptr++;
mh->max_stack = 8;
mh->is_transient = TRUE;
g_warning ("wrong signature for locals blob");
locals_ptr++;
len = mono_metadata_decode_value (locals_ptr, &locals_ptr);
- mh = g_malloc0 (MONO_SIZEOF_METHOD_HEADER + len * sizeof (MonoType*) + num_clauses * sizeof (MonoExceptionClause));
+ mh = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER + len * sizeof (MonoType*) + num_clauses * sizeof (MonoExceptionClause));
mh->num_locals = len;
for (i = 0; i < len; ++i) {
mh->locals [i] = mono_metadata_parse_type_internal (m, container,
goto fail;
}
} else {
- mh = g_malloc0 (MONO_SIZEOF_METHOD_HEADER + num_clauses * sizeof (MonoExceptionClause));
+ mh = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER + num_clauses * sizeof (MonoExceptionClause));
}
mh->code = code;
mh->code_size = code_size;
*clause = *sc;
return TRUE;
}
- sc = *iter;
+ sc = (MonoExceptionClause *)*iter;
sc++;
if (sc < header->clauses + header->num_clauses) {
*iter = sc;
if (heap_alloc_result)
result = g_new0 (MonoClass*, pos - start);
else
- result = mono_image_alloc0 (meta, sizeof (MonoClass*) * (pos - start));
+ result = (MonoClass **)mono_image_alloc0 (meta, sizeof (MonoClass*) * (pos - start));
pos = start;
while (pos < tdef->rows) {
if (o->num_mods)
sizeof_o += o->num_mods * sizeof (MonoCustomMod);
- r = image ? mono_image_alloc0 (image, sizeof_o) : g_malloc (sizeof_o);
+ r = image ? (MonoType *)mono_image_alloc0 (image, sizeof_o) : (MonoType *)g_malloc (sizeof_o);
memcpy (r, o, sizeof_o);
mono_error_init (error);
mono_image_lock (image);
- type = g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
+ type = (MonoType *)g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
mono_image_unlock (image);
if (type)
return type;
mono_metadata_free_type (type);
mono_image_lock (image);
- type = g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
+ type = (MonoType *)g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
/* We might leak some data in the image mempool if found */
if (!type) {
g_hash_table_insert (image->typespec_cache, GUINT_TO_POINTER (type_spec), type2);
char *res;
if (!image)
return g_strndup (data, len);
- res = mono_image_alloc (image, len + 1);
+ res = (char *)mono_image_alloc (image, len + 1);
memcpy (res, data, len);
res [len] = 0;
return res;
/* fixme: this is incomplete, but I cant find more infos in the specs */
if (image)
- res = mono_image_alloc0 (image, sizeof (MonoMarshalSpec));
+ res = (MonoMarshalSpec *)mono_image_alloc0 (image, sizeof (MonoMarshalSpec));
else
res = g_new0 (MonoMarshalSpec, 1);
len = mono_metadata_decode_value (ptr, &ptr);
- res->native = *ptr++;
+ res->native = (MonoMarshalNative)*ptr++;
if (res->native == MONO_NATIVE_LPARRAY) {
res->data.array_data.param_num = -1;
res->data.array_data.elem_mult = -1;
if (ptr - start <= len)
- res->data.array_data.elem_type = *ptr++;
+ res->data.array_data.elem_type = (MonoMarshalNative)*ptr++;
if (ptr - start <= len)
res->data.array_data.param_num = mono_metadata_decode_value (ptr, &ptr);
if (ptr - start <= len)
}
if (res->native == MONO_NATIVE_SAFEARRAY) {
- res->data.safearray_data.elem_type = 0;
+ res->data.safearray_data.elem_type = (MonoMarshalVariant)0;
res->data.safearray_data.num_elem = 0;
if (ptr - start <= len)
- res->data.safearray_data.elem_type = *ptr++;
+ res->data.safearray_data.elem_type = (MonoMarshalVariant)*ptr++;
if (ptr - start <= len)
res->data.safearray_data.num_elem = *ptr++;
}
}
if (!found)
return TRUE;
- res = mono_image_alloc0 (image, sizeof (MonoClass*) * (found + 1));
+ res = (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass*) * (found + 1));
for (i = 0, tmp = cons; i < found; ++i, tmp = tmp->next) {
- res [i] = tmp->data;
+ res [i] = (MonoClass *)tmp->data;
}
g_slist_free (cons);
*constraints = res;
mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
params = NULL;
n = 0;
- container = mono_image_alloc0 (image, sizeof (MonoGenericContainer));
+ container = (MonoGenericContainer *)mono_image_alloc0 (image, sizeof (MonoGenericContainer));
container->owner.image = image; // Temporarily mark as anonymous, but this will be overriden by caller
container->is_anonymous = TRUE;
do {
n++;
- params = g_realloc (params, sizeof (MonoGenericParamFull) * n);
+ params = (MonoGenericParamFull *)g_realloc (params, sizeof (MonoGenericParamFull) * n);
memset (¶ms [n - 1], 0, sizeof (MonoGenericParamFull));
params [n - 1].param.owner = container;
params [n - 1].param.num = cols [MONO_GENERICPARAM_NUMBER];
} while (cols [MONO_GENERICPARAM_OWNER] == owner);
container->type_argc = n;
- container->type_params = mono_image_alloc0 (image, sizeof (MonoGenericParamFull) * n);
+ container->type_params = (MonoGenericParamFull *)mono_image_alloc0 (image, sizeof (MonoGenericParamFull) * n);
memcpy (container->type_params, params, sizeof (MonoGenericParamFull) * n);
g_free (params);
container->parent = parent_container;
return NULL;
}
}
- type = *iter;
+ type = (MonoType **)*iter;
type++;
if (type < &sig->params [sig->param_count]) {
*iter = type;
if (image_sets)
{
for (i = 0; !owner && i < image_sets->len; ++i) {
- MonoImageSet *set = g_ptr_array_index (image_sets, i);
+ MonoImageSet *set = (MonoImageSet *)g_ptr_array_index (image_sets, i);
if (mono_mempool_contains_addr (set->mempool, ptr))
owner = set;
}
#ifndef DISABLE_JIT
mb->code_size = 40;
- mb->code = g_malloc (mb->code_size);
+ mb->code = (unsigned char *)g_malloc (mb->code_size);
#endif
/* placeholder for the wrapper always at index 1 */
mono_mb_add_data (mb, NULL);
{
/* Realloc the method info into a mempool */
- method = mono_image_alloc0 (image, sizeof (MonoMethodWrapper));
+ method = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodWrapper));
memcpy (method, mb->method, sizeof (MonoMethodWrapper));
mw = (MonoMethodWrapper*) method;
mw->header = header = (MonoMethodHeader *)
mono_image_alloc0 (image, MONO_SIZEOF_METHOD_HEADER + mb->locals * sizeof (MonoType *));
- header->code = mono_image_alloc (image, mb->pos);
+ header->code = (const unsigned char *)mono_image_alloc (image, mb->pos);
memcpy ((char*)header->code, mb->code, mb->pos);
for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
method->skip_visibility = mb->skip_visibility;
#endif
- i = g_list_length (mw->method_data);
+ i = g_list_length ((GList *)mw->method_data);
if (i) {
GList *tmp;
void **data;
- l = g_list_reverse (mw->method_data);
+ l = g_list_reverse ((GList *)mw->method_data);
if (method_is_dynamic (method))
- data = g_malloc (sizeof (gpointer) * (i + 1));
+ data = (void **)g_malloc (sizeof (gpointer) * (i + 1));
else
- data = mono_image_alloc (image, sizeof (gpointer) * (i + 1));
+ data = (void **)mono_image_alloc (image, sizeof (gpointer) * (i + 1));
/* store the size in the first element */
data [0] = GUINT_TO_POINTER (i);
i = 1;
#endif
if (mb->param_names) {
- char **param_names = mono_image_alloc0 (image, signature->param_count * sizeof (gpointer));
+ char **param_names = (char **)mono_image_alloc0 (image, signature->param_count * sizeof (gpointer));
for (i = 0; i < signature->param_count; ++i)
param_names [i] = mono_image_strdup (image, mb->param_names [i]);
mw = (MonoMethodWrapper *)mb->method;
/* one O(n) is enough */
- mw->method_data = g_list_prepend (mw->method_data, data);
+ mw->method_data = g_list_prepend ((GList *)mw->method_data, data);
- return g_list_length (mw->method_data);
+ return g_list_length ((GList *)mw->method_data);
}
#ifndef DISABLE_JIT
{
if (mb->pos >= mb->code_size) {
mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
+ mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
}
mb->code [mb->pos++] = op;
{
if ((mb->pos + 4) >= mb->code_size) {
mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
+ mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
}
mono_mb_patch_addr (mb, mb->pos, data);
{
if ((mb->pos + 8) >= mb->code_size) {
mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
+ mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
}
mono_mb_patch_addr (mb, mb->pos, data);
{
if ((mb->pos + 2) >= mb->code_size) {
mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
+ mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
}
mb->code [mb->pos] = data & 0xff;
/*mono_os_mutex_destroy (&monitor_mutex);*/
/* The monitors on the freelist don't have weak links - mark them */
- for (mon = monitor_freelist; mon; mon = mon->data)
- mon->wait_list = (gpointer)-1;
+ for (mon = monitor_freelist; mon; mon = (MonoThreadsSync *)mon->data)
+ mon->wait_list = (GSList *)-1;
/*
* FIXME: This still crashes with sgen (async_read.exe)
int used = 0, on_freelist = 0, to_recycle = 0, total = 0, num_arrays = 0;
MonoThreadsSync *mon;
MonitorArray *marray;
- for (mon = monitor_freelist; mon; mon = mon->data)
+ for (mon = monitor_freelist; mon; mon = (MonoThreadsSync *)mon->data)
on_freelist++;
for (marray = monitor_allocated; marray; marray = marray->next) {
total += marray->num_monitors;
if (i < marray->num_monitors - 1)
to_recycle++;
} else {
- if (!monitor_is_on_freelist (mon->data)) {
+ if (!monitor_is_on_freelist ((MonoThreadsSync *)mon->data)) {
MonoObject *holder = (MonoObject *)mono_gchandle_get_target ((guint32)mon->data);
if (mon_status_get_owner (mon->status)) {
g_print ("Lock %p in object %p held by thread %d, nest level: %d\n",
static MonoThreadsSync *
mon_new (gsize id)
{
- MonoThreadsSync *new;
+ MonoThreadsSync *new_;
if (!monitor_freelist) {
MonitorArray *marray;
int i;
/* see if any sync block has been collected */
- new = NULL;
+ new_ = NULL;
for (marray = monitor_allocated; marray; marray = marray->next) {
for (i = 0; i < marray->num_monitors; ++i) {
if (mono_gchandle_get_target ((guint32)marray->monitors [i].data) == NULL) {
- new = &marray->monitors [i];
- if (new->wait_list) {
+ new_ = &marray->monitors [i];
+ if (new_->wait_list) {
/* Orphaned events left by aborted threads */
- while (new->wait_list) {
+ while (new_->wait_list) {
LOCK_DEBUG (g_message (G_GNUC_PRETTY_FUNCTION ": (%d): Closing orphaned event %d", mono_thread_info_get_small_id (), new->wait_list->data));
- CloseHandle (new->wait_list->data);
- new->wait_list = g_slist_remove (new->wait_list, new->wait_list->data);
+ CloseHandle (new_->wait_list->data);
+ new_->wait_list = g_slist_remove (new_->wait_list, new_->wait_list->data);
}
}
- mono_gchandle_free ((guint32)new->data);
- new->data = monitor_freelist;
- monitor_freelist = new;
+ mono_gchandle_free ((guint32)new_->data);
+ new_->data = monitor_freelist;
+ monitor_freelist = new_;
}
}
/* small perf tweak to avoid scanning all the blocks */
- if (new)
+ if (new_)
break;
}
/* need to allocate a new array of monitors */
if (!monitor_freelist) {
MonitorArray *last;
LOCK_DEBUG (g_message ("%s: allocating more monitors: %d", __func__, array_size));
- marray = g_malloc0 (MONO_SIZEOF_MONO_ARRAY + array_size * sizeof (MonoThreadsSync));
+ marray = (MonitorArray *)g_malloc0 (MONO_SIZEOF_MONO_ARRAY + array_size * sizeof (MonoThreadsSync));
marray->num_monitors = array_size;
array_size *= 2;
/* link into the freelist */
}
}
- new = monitor_freelist;
- monitor_freelist = new->data;
+ new_ = monitor_freelist;
+ monitor_freelist = (MonoThreadsSync *)new_->data;
- new->status = mon_status_set_owner (0, id);
- new->status = mon_status_init_entry_count (new->status);
- new->nest = 1;
- new->data = NULL;
+ new_->status = mon_status_set_owner (0, id);
+ new_->status = mon_status_init_entry_count (new_->status);
+ new_->nest = 1;
+ new_->data = NULL;
#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->gc_sync_blocks++;
#endif
- return new;
+ return new_;
}
static MonoThreadsSync*
nlw = lock_word_new_inflated (mon);
mono_memory_write_barrier ();
- tmp_lw.sync = InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, nlw.sync, old_lw.sync);
+ tmp_lw.sync = (MonoThreadsSync *)InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, nlw.sync, old_lw.sync);
if (tmp_lw.sync != old_lw.sync) {
/* Someone else inflated the lock in the meantime */
discard_mon (mon);
mon->nest = lock_word_get_nest (old_lw);
}
mono_memory_write_barrier ();
- tmp_lw.sync = InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, nlw.sync, old_lw.sync);
+ tmp_lw.sync = (MonoThreadsSync *)InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, nlw.sync, old_lw.sync);
if (tmp_lw.sync == old_lw.sync) {
/* Successfully inflated the lock */
return;
LockWord old_lw;
lw = lock_word_new_thin_hash (hash);
- old_lw.sync = InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, lw.sync, NULL);
+ old_lw.sync = (MonoThreadsSync *)InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, lw.sync, NULL);
if (old_lw.sync == NULL) {
return hash;
}
else
new_lw.lock_word = 0;
- tmp_lw.sync = InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, new_lw.sync, old_lw.sync);
+ tmp_lw.sync = (MonoThreadsSync *)InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, new_lw.sync, old_lw.sync);
if (old_lw.sync != tmp_lw.sync) {
/* Someone inflated the lock in the meantime */
mono_monitor_exit_inflated (obj);
* We have to obey a stop/suspend request even if
* allow_interruption is FALSE to avoid hangs at shutdown.
*/
- if (!mono_thread_test_state (mono_thread_internal_current (), (ThreadState_StopRequested|ThreadState_SuspendRequested))) {
+ if (!mono_thread_test_state (mono_thread_internal_current (), (MonoThreadState)(ThreadState_StopRequested | ThreadState_SuspendRequested))) {
if (ms != INFINITE) {
now = mono_msec_ticks ();
if (now < then) {
} else {
LockWord nlw, old_lw;
nlw = lock_word_increment_nest (lw);
- old_lw.sync = InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, nlw.sync, lw.sync);
+ old_lw.sync = (MonoThreadsSync *)InterlockedCompareExchangePointer ((gpointer*)&obj->synchronisation, nlw.sync, lw.sync);
if (old_lw.sync != lw.sync) {
/* Someone else inflated it in the meantime */
g_assert (lock_word_is_inflated (old_lw));
}
while (mark_stack->len > 0) {
- MonoSimpleBasicBlock *block = g_ptr_array_remove_index_fast (mark_stack, mark_stack->len - 1);
+ MonoSimpleBasicBlock *block = (MonoSimpleBasicBlock *)g_ptr_array_remove_index_fast (mark_stack, mark_stack->len - 1);
block->dead = FALSE;
for (tmp = block->out_bb; tmp; tmp = tmp->next) {
- MonoSimpleBasicBlock *to = tmp->data;
+ MonoSimpleBasicBlock *to = (MonoSimpleBasicBlock *)tmp->data;
if (to->dead)
g_ptr_array_add (mark_stack, to);
}
gpointer user_data,
GError **error)
{
- ParseState *state = user_data;
+ ParseState *state = (ParseState *)user_data;
if (!state->current) {
- state->current = g_hash_table_lookup (config_handlers, element_name);
+ state->current = (MonoParseHandler *)g_hash_table_lookup (config_handlers, element_name);
if (state->current && state->current->init)
state->user_data = state->current->init (state->assembly);
}
gpointer user_data,
GError **error)
{
- ParseState *state = user_data;
+ ParseState *state = (ParseState *)user_data;
if (state->current) {
if (state->current->end)
state->current->end (state->user_data, element_name);
gpointer user_data,
GError **error)
{
- ParseState *state = user_data;
+ ParseState *state = (ParseState *)user_data;
if (state->current && state->current->text)
state->current->text (state->user_data, text, text_len);
}
GError *error,
gpointer user_data)
{
- ParseState *state = user_data;
+ ParseState *state = (ParseState *)user_data;
const gchar *msg;
const gchar *filename;
const gchar **attribute_values)
{
int i;
- DllInfo *info = user_data;
+ DllInfo *info = (DllInfo *)user_data;
if (strcmp (element_name, "dllmap") == 0) {
g_free (info->dll);
size_t libdir_len = strlen (libdir);
char *result;
- result = g_malloc (libdir_len-strlen("$mono_libdir")+strlen(attribute_values[i])+1);
+ result = (char *)g_malloc (libdir_len-strlen("$mono_libdir")+strlen(attribute_values[i])+1);
strncpy (result, attribute_names[i], p-attribute_values[i]);
strcat (result, libdir);
strcat (result, p+strlen("$mono_libdir"));
static void
dllmap_finish (gpointer user_data)
{
- DllInfo *info = user_data;
+ DllInfo *info = (DllInfo *)user_data;
g_free (info->dll);
g_free (info->target);
if (!inited)
mono_config_init ();
- context = g_markup_parse_context_new (&mono_parser, 0, state, NULL);
+ context = g_markup_parse_context_new (&mono_parser, (GMarkupParseFlags)0, state, NULL);
if (g_markup_parse_context_parse (context, text, len, NULL)) {
g_markup_parse_context_end_parse (context, NULL);
}
static void
assembly_binding_end (gpointer user_data, const char *element_name)
{
- ParserUserData *pud = user_data;
+ ParserUserData *pud = (ParserUserData *)user_data;
if (!strcmp (element_name, "dependentAssembly")) {
if (pud->info_parsed && pud->info) {
MonoAssemblyBindingInfo *info;
int n;
- pud = user_data;
+ pud = (ParserUserData *)user_data;
info = pud->info;
if (!strcmp (element_name, "dependentAssembly")) {
info->name = NULL;
{
MonoDebugDataTable *table;
- table = g_hash_table_lookup (data_table_hash, domain);
+ table = (MonoDebugDataTable *)g_hash_table_lookup (data_table_hash, domain);
if (!table) {
g_error ("lookup_data_table () failed for %p\n", domain);
g_assert (table);
mono_debugger_lock ();
- table = g_hash_table_lookup (data_table_hash, domain);
+ table = (MonoDebugDataTable *)g_hash_table_lookup (data_table_hash, domain);
if (!table) {
g_warning (G_STRLOC ": unloading unknown domain %p / %d",
domain, mono_domain_get_id (domain));
static MonoDebugHandle *
mono_debug_get_image (MonoImage *image)
{
- return g_hash_table_lookup (mono_debug_handles, image);
+ return (MonoDebugHandle *)g_hash_table_lookup (mono_debug_handles, image);
}
void
(25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals);
if (max_size > BUFSIZ)
- ptr = oldptr = g_malloc (max_size);
+ ptr = oldptr = (guint8 *)g_malloc (max_size);
else
ptr = oldptr = buffer;
total_size = size + sizeof (MonoDebugMethodAddress);
if (method_is_dynamic (method)) {
- address = g_malloc0 (total_size);
+ address = (MonoDebugMethodAddress *)g_malloc0 (total_size);
} else {
- address = mono_mempool_alloc (table->mp, total_size);
+ address = (MonoDebugMethodAddress *)mono_mempool_alloc (table->mp, total_size);
}
address->code_start = jit->code_start;
table = lookup_data_table (domain);
- address = g_hash_table_lookup (table->method_address_hash, method);
+ address = (MonoDebugMethodAddress *)g_hash_table_lookup (table->method_address_hash, method);
if (address)
g_free (address);
var->size = read_leb128 (ptr, &ptr);
var->begin_scope = read_leb128 (ptr, &ptr);
var->end_scope = read_leb128 (ptr, &ptr);
- READ_UNALIGNED (gpointer, ptr, var->type);
+ READ_UNALIGNED (MonoType *, ptr, var->type);
ptr += sizeof (gpointer);
*rptr = ptr;
}
MonoDebugMethodAddress *address;
table = lookup_data_table (domain);
- address = g_hash_table_lookup (table->method_address_hash, method);
+ address = (MonoDebugMethodAddress *)g_hash_table_lookup (table->method_address_hash, method);
if (!address)
return NULL;
static void*
do_rehash (void *_data)
{
- RehashData *data = _data;
+ RehashData *data = (RehashData *)_data;
MonoGHashTable *hash = data->hash;
int current_size, i;
Slot **table;
if (replace){
if (hash->key_destroy_func != NULL)
(*hash->key_destroy_func)(s->key);
- s->key = key;
+ s->key = (MonoObject *)key;
}
if (hash->value_destroy_func != NULL)
(*hash->value_destroy_func) (s->value);
- s->value = value;
+ s->value = (MonoObject *)value;
return;
}
}
s = new_slot (hash);
- s->key = key;
- s->value = value;
+ s->key = (MonoObject *)key;
+ s->value = (MonoObject *)value;
s->next = hash->table [hashcode];
hash->table [hashcode] = s;
hash->in_use++;
perfctr_lock ();
if (pid_to_shared_area == NULL)
pid_to_shared_area = g_hash_table_new (NULL, NULL);
- data = g_hash_table_lookup (pid_to_shared_area, GINT_TO_POINTER (pid));
+ data = (ExternalSArea *)g_hash_table_lookup (pid_to_shared_area, GINT_TO_POINTER (pid));
if (!data) {
- area = mono_shared_area_for_pid (GINT_TO_POINTER (pid));
+ area = (MonoSharedArea *)mono_shared_area_for_pid (GINT_TO_POINTER (pid));
if (area) {
data = g_new (ExternalSArea, 1);
data->sarea = area;
g_hash_table_insert (pid_to_shared_area, GINT_TO_POINTER (pid), data);
}
} else {
- area = data->sarea;
+ area = (MonoSharedArea *)data->sarea;
data->refcount ++;
}
perfctr_unlock ();
unref_pid_unlocked (int pid)
{
ExternalSArea *data;
- data = g_hash_table_lookup (pid_to_shared_area, GINT_TO_POINTER (pid));
+ data = (ExternalSArea *)g_hash_table_lookup (pid_to_shared_area, GINT_TO_POINTER (pid));
if (data) {
data->refcount--;
if (!data->refcount) {
mono_os_mutex_init_recursive (&perfctr_mutex);
- shared_area = mono_shared_area ();
+ shared_area = (MonoSharedArea *)mono_shared_area ();
shared_area->counters_start = G_STRUCT_OFFSET (MonoSharedArea, counters);
shared_area->counters_size = sizeof (MonoPerfCounters);
shared_area->data_start = d_offset;
static gboolean
category_search (SharedHeader *header, void *data)
{
- CatSearch *search = data;
+ CatSearch *search = (CatSearch *)data;
if (header->ftype == FTYPE_CATEGORY) {
SharedCategory *cat = (SharedCategory*)header;
if (mono_string_compare_ascii (search->name, cat->name) == 0) {
static gboolean
category_collect (SharedHeader *header, void *data)
{
- GSList **list = data;
+ GSList **list = (GSList **)data;
if (header->ftype == FTYPE_CATEGORY) {
*list = g_slist_prepend (*list, header);
}
static gboolean
instance_search (SharedHeader *header, void *data)
{
- InstanceSearch *search = data;
+ InstanceSearch *search = (InstanceSearch *)data;
if (header->ftype == FTYPE_INSTANCE) {
SharedInstance *ins = (SharedInstance*)header;
if (search->cat_offset == ins->category_offset) {
if (vtable == NULL)
return;
- narg = vtable->arg;
+ narg = (NetworkVtableArg *)vtable->arg;
if (narg == NULL)
return;
custom_writable_update (ImplVtable *vtable, MonoBoolean do_incr, gint64 value)
{
/* FIXME: check writability */
- guint64 *ptr = vtable->arg;
+ guint64 *ptr = (guint64 *)vtable->arg;
if (ptr) {
if (do_incr) {
/* FIXME: we need to do this atomically */
g_free (name);
if (!inst)
return NULL;
- return custom_vtable (scounter, inst, custom_get_value_address (scounter, inst));
+ return custom_vtable (scounter, inst, (char *)custom_get_value_address (scounter, inst));
}
static const CategoryDesc*
MonoBoolean
mono_perfcounter_get_sample (void *impl, MonoBoolean only_value, MonoCounterSample *sample)
{
- ImplVtable *vtable = impl;
+ ImplVtable *vtable = (ImplVtable *)impl;
if (vtable && vtable->sample)
return vtable->sample (vtable, only_value, sample);
return FALSE;
gint64
mono_perfcounter_update_value (void *impl, MonoBoolean do_incr, gint64 value)
{
- ImplVtable *vtable = impl;
+ ImplVtable *vtable = (ImplVtable *)impl;
if (vtable && vtable->update)
return vtable->update (vtable, do_incr, value);
return 0;
void
mono_perfcounter_free_data (void *impl)
{
- ImplVtable *vtable = impl;
+ ImplVtable *vtable = (ImplVtable *)impl;
if (vtable && vtable->cleanup)
vtable->cleanup (vtable);
g_free (impl);
mono_array_setref (res, i, mono_string_new (domain, cdesc->name));
}
for (tmp = custom_categories; tmp; tmp = tmp->next) {
- SharedCategory *scat = tmp->data;
+ SharedCategory *scat = (SharedCategory *)tmp->data;
mono_array_setref (res, i, mono_string_new (domain, scat->name));
i++;
}
MonoDomain *domain = mono_domain_get ();
MonoArray * res = mono_array_new (mono_domain_get (), mono_get_string_class (), count);
for (i = 0; i < count; ++i) {
- char* p = array[i];
+ char* p = (char *)array[i];
mono_array_setref (res, i, mono_string_new (domain, p));
}
int i = 0;
MonoArray *array = mono_array_new (mono_domain_get (), mono_get_string_class (), g_slist_length (list));
for (tmp = list; tmp; tmp = tmp->next) {
- SharedInstance *inst = tmp->data;
+ SharedInstance *inst = (SharedInstance *)tmp->data;
mono_array_setref (array, i, mono_string_new (mono_domain_get (), inst->instance_name));
i++;
}
SharedCategory *cat;
SharedCounter *counter;
SharedInstance *inst;
- PerfCounterForeachData *foreach_data = data;
+ PerfCounterForeachData *foreach_data = (PerfCounterForeachData *)data;
if (header->ftype == FTYPE_CATEGORY) {
cat = (SharedCategory*)header;
(ARRAY).capacity = MAX (INITIAL_SIZE, MONO_PTR_ARRAY_MAX_ON_STACK); \
(ARRAY).source = SOURCE; \
(ARRAY).msg = MSG; \
- (ARRAY).data = INITIAL_SIZE > MONO_PTR_ARRAY_MAX_ON_STACK ? mono_gc_alloc_fixed (sizeof (void*) * INITIAL_SIZE, mono_gc_make_root_descr_all_refs (INITIAL_SIZE), SOURCE, MSG) : g_newa (void*, MONO_PTR_ARRAY_MAX_ON_STACK); \
+ (ARRAY).data = INITIAL_SIZE > MONO_PTR_ARRAY_MAX_ON_STACK \
+ ? (void **)mono_gc_alloc_fixed (sizeof (void*) * INITIAL_SIZE, mono_gc_make_root_descr_all_refs (INITIAL_SIZE), SOURCE, MSG) \
+ : g_newa (void*, MONO_PTR_ARRAY_MAX_ON_STACK); \
} while (0)
#define mono_ptr_array_destroy(ARRAY) do {\
#define mono_ptr_array_append(ARRAY, VALUE) do { \
if ((ARRAY).size >= (ARRAY).capacity) {\
- void *__tmp = mono_gc_alloc_fixed (sizeof (void*) * (ARRAY).capacity * 2, mono_gc_make_root_descr_all_refs ((ARRAY).capacity * 2), (ARRAY).source, (ARRAY).msg); \
- mono_gc_memmove_aligned (__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void*)); \
+ void **__tmp = (void **)mono_gc_alloc_fixed (sizeof (void*) * (ARRAY).capacity * 2, mono_gc_make_root_descr_all_refs ((ARRAY).capacity * 2), (ARRAY).source, (ARRAY).msg); \
+ mono_gc_memmove_aligned ((void *)__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void*)); \
if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK) \
mono_gc_free_fixed ((ARRAY).data); \
(ARRAY).data = __tmp; \
#else
fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
- fbuf = g_malloc0 (fbufsize);
+ fbuf = (gchar *)g_malloc0 (fbufsize);
retval = getpwuid_r (uid, &pwd, fbuf, fbufsize, &p);
result = ((retval == 0) && (p == &pwd));
#else
fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
- fbuf = g_malloc0 (fbufsize);
+ fbuf = (gchar *)g_malloc0 (fbufsize);
retval = getpwuid_r (user, &pwd, fbuf, fbufsize, &p);
result = ((retval == 0) && (p == &pwd));
#else
fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
- fbuf = g_malloc0 (fbufsize);
+ fbuf = (gchar *)g_malloc0 (fbufsize);
retval = getpwnam_r (utf8_name, &pwd, fbuf, fbufsize, &p);
result = ((retval == 0) && (p == &pwd));
#else
#else
fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
- fbuf = g_malloc0 (fbufsize);
+ fbuf = (gchar *)g_malloc0 (fbufsize);
retval = getgrgid_r ((gid_t) GPOINTER_TO_INT (group), &grp, fbuf, fbufsize, &g);
result = ((retval == 0) && (g == &grp));
#else
#else
size_t fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
- fbuf = g_malloc0 (fbufsize);
+ fbuf = (gchar *)g_malloc0 (fbufsize);
retval = getgrnam_r (utf8_groupname, &grp, fbuf, fbufsize, &g);
result = ((retval == 0) && (g == &grp));
#else
g_error ("Could not lookup zero argument constructor for class %s", mono_type_get_full_name (klass));
if (method->klass->valuetype)
- this_obj = mono_object_unbox (this_obj);
+ this_obj = (MonoObject *)mono_object_unbox (this_obj);
mono_runtime_invoke (method, this_obj, NULL, NULL);
}
ex = NULL;
mono_domain_lock (domain);
if (domain->type_init_exception_hash)
- ex = mono_g_hash_table_lookup (domain->type_init_exception_hash, klass);
+ ex = (MonoException *)mono_g_hash_table_lookup (domain->type_init_exception_hash, klass);
mono_domain_unlock (domain);
if (!ex) {
mono_raise_exception (get_type_init_exception_for_vtable (vtable));
return get_type_init_exception_for_vtable (vtable);
}
- lock = g_hash_table_lookup (type_initialization_hash, vtable);
+ lock = (TypeInitializationLock *)g_hash_table_lookup (type_initialization_hash, vtable);
if (lock == NULL) {
/* This thread will get to do the initialization */
if (mono_domain_get () != domain) {
return mono_get_exception_appdomain_unloaded ();
}
}
- lock = g_malloc (sizeof(TypeInitializationLock));
+ lock = (TypeInitializationLock *)g_malloc (sizeof (TypeInitializationLock));
mono_coop_mutex_init_recursive (&lock->initialization_section);
lock->initializing_tid = tid;
lock->waiting_count = 1;
max_size = klass->instance_size / sizeof (gpointer);
if (max_size > size) {
g_assert (offset <= 0);
- bitmap = g_malloc0 ((max_size + BITMAP_EL_SIZE - 1) / BITMAP_EL_SIZE * sizeof (gsize));
+ bitmap = (gsize *)g_malloc0 ((max_size + BITMAP_EL_SIZE - 1) / BITMAP_EL_SIZE * sizeof (gsize));
size = max_size;
}
sig = mono_method_signature (method);
hashes_count = sig->param_count + 4;
- hashes_start = malloc (hashes_count * sizeof (guint32));
+ hashes_start = (guint32 *)malloc (hashes_count * sizeof (guint32));
hashes = hashes_start;
if (! MONO_CLASS_IS_INTERFACE (method->klass)) {
return;
}
- entry = g_malloc0 (sizeof (MonoImtBuilderEntry));
+ entry = (MonoImtBuilderEntry *)g_malloc0 (sizeof (MonoImtBuilderEntry));
entry->key = method;
entry->value.vtable_slot = vtable_slot;
entry->next = imt_builder [imt_slot];
MONO_REQ_GC_NEUTRAL_MODE;
int number_of_entries = entries->children + 1;
- MonoImtBuilderEntry **sorted_array = malloc (sizeof (MonoImtBuilderEntry*) * number_of_entries);
+ MonoImtBuilderEntry **sorted_array = (MonoImtBuilderEntry **)malloc (sizeof (MonoImtBuilderEntry*) * number_of_entries);
GPtrArray *result = g_ptr_array_new ();
MonoImtBuilderEntry *current_entry;
int i;
int i;
GSList *list_item;
guint32 imt_collisions_bitmap = 0;
- MonoImtBuilderEntry **imt_builder = calloc (MONO_IMT_SIZE, sizeof (MonoImtBuilderEntry*));
+ MonoImtBuilderEntry **imt_builder = (MonoImtBuilderEntry **)calloc (MONO_IMT_SIZE, sizeof (MonoImtBuilderEntry*));
int method_count = 0;
gboolean record_method_count_for_max_collisions = FALSE;
gboolean has_generic_virtual = FALSE, has_variant_iface = FALSE;
int interface_offset = klass->vtable_size;
for (list_item = extra_interfaces; list_item != NULL; list_item=list_item->next) {
- MonoClass* iface = list_item->data;
+ MonoClass* iface = (MonoClass *)list_item->data;
int method_slot_in_interface;
for (method_slot_in_interface = 0; method_slot_in_interface < iface->method.count; method_slot_in_interface++) {
MonoMethod *method = mono_class_get_method_by_index (iface, method_slot_in_interface);
if (domain->thunk_free_lists)
return;
- domain->thunk_free_lists = mono_domain_alloc0 (domain, sizeof (gpointer) * NUM_FREE_LISTS);
+ domain->thunk_free_lists = (MonoThunkFreeList **)mono_domain_alloc0 (domain, sizeof (gpointer) * NUM_FREE_LISTS);
}
static int
}
generic_virtual_thunks_size += size;
- p = mono_domain_code_reserve (domain, size);
+ p = (guint32 *)mono_domain_code_reserve (domain, size);
*p = size;
mono_domain_lock (domain);
{
MONO_REQ_GC_NEUTRAL_MODE;
- guint32 *p = code;
+ guint32 *p = (guint32 *)code;
MonoThunkFreeList *l = (MonoThunkFreeList*)(p - 1);
gboolean found = FALSE;
if (!domain->generic_virtual_cases)
domain->generic_virtual_cases = g_hash_table_new (mono_aligned_addr_hash, NULL);
- list = g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
+ list = (GenericVirtualCase *)g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
entries = NULL;
for (; list; list = list->next) {
domain->generic_virtual_cases = g_hash_table_new (mono_aligned_addr_hash, NULL);
/* Check whether the case was already added */
- list = g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
+ list = (GenericVirtualCase *)g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
gvc = list;
while (gvc) {
if (gvc->method == method)
/* If not found, make a new one */
if (!gvc) {
- gvc = mono_domain_alloc (domain, sizeof (GenericVirtualCase));
+ gvc = (GenericVirtualCase *)mono_domain_alloc (domain, sizeof (GenericVirtualCase));
gvc->method = method;
gvc->code = code;
gvc->count = 0;
- gvc->next = g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
+ gvc->next = (GenericVirtualCase *)g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
g_hash_table_insert (domain->generic_virtual_cases, vtable_slot, gvc);
}
if (++gvc->count == THUNK_THRESHOLD) {
- gpointer *old_thunk = *vtable_slot;
+ gpointer *old_thunk = (void **)*vtable_slot;
gpointer vtable_trampoline = NULL;
gpointer imt_trampoline = NULL;
if (klass != mono_defaults.monotype_class) {
/*FIXME check for OOM*/
vt->type = mono_type_get_object (domain, &klass->byval_arg);
- if (mono_object_get_class (vt->type) != mono_defaults.monotype_class)
+ if (mono_object_get_class ((MonoObject *)vt->type) != mono_defaults.monotype_class)
/* This is unregistered in
unregister_vtable_reflection_type() in
domain.c. */
/* this is a bounded memory retention issue: may want to
* handle it differently when we'll have a rcu-like system.
*/
- runtime_info = mono_image_alloc0 (klass->image, MONO_SIZEOF_CLASS_RUNTIME_INFO + new_size * sizeof (gpointer));
+ runtime_info = (MonoClassRuntimeInfo *)mono_image_alloc0 (klass->image, MONO_SIZEOF_CLASS_RUNTIME_INFO + new_size * sizeof (gpointer));
runtime_info->max_domain = new_size - 1;
/* copy the stuff from the older info */
if (old_info) {
if (klass == mono_defaults.monotype_class) {
/*FIXME check for OOM*/
vt->type = mono_type_get_object (domain, &klass->byval_arg);
- if (mono_object_get_class (vt->type) != mono_defaults.monotype_class)
+ if (mono_object_get_class ((MonoObject *)vt->type) != mono_defaults.monotype_class)
/* This is unregistered in
unregister_vtable_reflection_type() in
domain.c. */
g_assert (mono_error_ok (&error)); /*FIXME do proper error handling*/
if (ifaces) {
for (i = 0; i < ifaces->len; ++i) {
- MonoClass *ic = g_ptr_array_index (ifaces, i);
+ MonoClass *ic = (MonoClass *)g_ptr_array_index (ifaces, i);
/*FIXME test for interfaces with variant generic arguments*/
if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass, ic->interface_id))
continue; /* interface implemented by the class */
pvt->max_interface_id = max_interface_id;
bsize = sizeof (guint8) * (max_interface_id/8 + 1 );
#ifdef COMPRESSED_INTERFACE_BITMAP
- bitmap = g_malloc0 (bsize);
+ bitmap = (uint8_t *)g_malloc0 (bsize);
#else
- bitmap = mono_domain_alloc0 (domain, bsize);
+ bitmap = (uint8_t *)mono_domain_alloc0 (domain, bsize);
#endif
for (i = 0; i < klass->interface_offsets_count; ++i) {
/* Create trampolines for the methods of the interfaces */
for (list_item = extra_interfaces; list_item != NULL; list_item=list_item->next) {
- interf = list_item->data;
+ interf = (MonoClass *)list_item->data;
bitmap [interf->interface_id >> 3] |= (1 << (interf->interface_id & 7));
if (remote_class == NULL) {
if (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
- key = g_malloc (sizeof(gpointer) * 3);
+ key = (void **)g_malloc (sizeof(gpointer) * 3);
key [0] = GINT_TO_POINTER (2);
key [1] = mono_defaults.marshalbyrefobject_class;
key [2] = extra_class;
} else {
- key = g_malloc (sizeof(gpointer) * 2);
+ key = (void **)g_malloc (sizeof(gpointer) * 2);
key [0] = GINT_TO_POINTER (1);
key [1] = extra_class;
}
} else {
if (extra_class != NULL && (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE)) {
- key = g_malloc (sizeof(gpointer) * (remote_class->interface_count + 3));
+ key = (void **)g_malloc (sizeof(gpointer) * (remote_class->interface_count + 3));
key [0] = GINT_TO_POINTER (remote_class->interface_count + 2);
key [1] = remote_class->proxy_class;
key [j] = extra_class;
} else {
// Replace the old class. The interface list is the same
- key = g_malloc (sizeof(gpointer) * (remote_class->interface_count + 2));
+ key = (void **)g_malloc (sizeof(gpointer) * (remote_class->interface_count + 2));
key [0] = GINT_TO_POINTER (remote_class->interface_count + 1);
key [1] = extra_class != NULL ? extra_class : remote_class->proxy_class;
for (i = 0; i < remote_class->interface_count; i++)
MONO_REQ_GC_NEUTRAL_MODE
int key_size = (GPOINTER_TO_UINT (key [0]) + 1) * sizeof (gpointer);
- gpointer *mp_key = mono_domain_alloc (domain, key_size);
+ gpointer *mp_key = (gpointer *)mono_domain_alloc (domain, key_size);
memcpy (mp_key, key, key_size);
key = create_remote_class_key (NULL, proxy_class);
mono_domain_lock (domain);
- rc = g_hash_table_lookup (domain->proxy_vtable_hash, key);
+ rc = (MonoRemoteClass *)g_hash_table_lookup (domain->proxy_vtable_hash, key);
if (rc) {
g_free (key);
key = mp_key;
if (proxy_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
- rc = mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*));
+ rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*));
rc->interface_count = 1;
rc->interfaces [0] = proxy_class;
rc->proxy_class = mono_defaults.marshalbyrefobject_class;
} else {
- rc = mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS);
+ rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS);
rc->interface_count = 0;
rc->proxy_class = proxy_class;
}
gpointer* key, *mp_key;
key = create_remote_class_key (remote_class, extra_class);
- rc = g_hash_table_lookup (domain->proxy_vtable_hash, key);
+ rc = (MonoRemoteClass *)g_hash_table_lookup (domain->proxy_vtable_hash, key);
if (rc != NULL) {
g_free (key);
return rc;
if (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
int i,j;
- rc = mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*) * (remote_class->interface_count + 1));
+ rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*) * (remote_class->interface_count + 1));
rc->proxy_class = remote_class->proxy_class;
rc->interface_count = remote_class->interface_count + 1;
rc->interfaces [j] = extra_class;
} else {
// Replace the old class. The interface array is the same
- rc = mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*) * remote_class->interface_count);
+ rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*) * remote_class->interface_count);
rc->proxy_class = extra_class;
rc->interface_count = remote_class->interface_count;
if (rc->interface_count > 0)
if (redo_vtable) {
tproxy->remote_class = clone_remote_class (domain, remote_class, klass);
- proxy_object->vtable = mono_remote_class_vtable (domain, tproxy->remote_class, tproxy->rp);
+ proxy_object->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tproxy->remote_class, tproxy->rp);
}
mono_domain_unlock (domain);
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_ARRAY:
- mono_gc_wbarrier_generic_store (dest, deref_pointer? *(gpointer*)value: value);
+ mono_gc_wbarrier_generic_store (dest, deref_pointer ? *(MonoObject **)value : (MonoObject *)value);
return;
case MONO_TYPE_FNPTR:
case MONO_TYPE_PTR: {
mono_domain_lock (vt->domain);
addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
mono_domain_unlock (vt->domain);
- src = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
+ src = (guint8 *)mono_get_special_static_data (GPOINTER_TO_UINT (addr));
} else {
src = (guint8*)mono_vtable_get_static_field_data (vt) + field->offset;
}
gboolean has_byref_nullables = FALSE;
if (NULL != params) {
- pa = alloca (sizeof (gpointer) * mono_array_length (params));
+ pa = (void **)alloca (sizeof (gpointer) * mono_array_length (params));
for (i = 0; i < mono_array_length (params); i++) {
MonoType *t = sig->params [i];
}
#endif
if (method->klass->valuetype)
- o = mono_object_unbox (obj);
+ o = (MonoObject *)mono_object_unbox ((MonoObject *)obj);
else
o = obj;
} else if (method->klass->valuetype) {
}
mono_runtime_invoke (method, o, pa, exc);
- return obj;
+ return (MonoObject *)obj;
} else {
if (mono_class_is_nullable (method->klass)) {
MonoObject *nullable;
/* Convert the unboxed vtype into a Nullable structure */
nullable = mono_object_new (mono_domain_get (), method->klass);
- mono_nullable_init (mono_object_unbox (nullable), mono_value_box (mono_domain_get (), method->klass->cast_class, obj), method->klass);
+ mono_nullable_init ((guint8 *)mono_object_unbox (nullable), mono_value_box (mono_domain_get (), method->klass->cast_class, obj), method->klass);
obj = mono_object_unbox (nullable);
}
return NULL;
#ifdef HAVE_SGEN_GC
- return mono_gc_alloc_pinned_obj (vtable, mono_class_instance_size (klass));
+ return (MonoObject *)mono_gc_alloc_pinned_obj (vtable, mono_class_instance_size (klass));
#else
return mono_object_new_specific (vtable);
#endif
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoObject *o = mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
+ MonoObject *o = (MonoObject *)mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
if (G_UNLIKELY (vtable->klass->has_finalize))
mono_object_register_finalizer (o);
{
MONO_REQ_GC_UNSAFE_MODE;
- return mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
+ return (MonoObject *)mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
}
/**
if (obj->vtable->klass->rank)
return (MonoObject*)mono_array_clone ((MonoArray*)obj);
- o = mono_gc_alloc_obj (obj->vtable, size);
+ o = (MonoObject *)mono_gc_alloc_obj (obj->vtable, size);
/* If the object doesn't contain references this will do a simple memmove. */
mono_gc_wbarrier_object_copy (o, obj);
return o;
}
- sizes = alloca (klass->rank * sizeof(intptr_t) * 2);
+ sizes = (uintptr_t *)alloca (klass->rank * sizeof(intptr_t) * 2);
size = mono_array_element_size (klass);
for (i = 0; i < klass->rank; ++i) {
sizes [i] = array->bounds [i].length;
*/
vtable = mono_class_vtable_full (domain, array_class, TRUE);
if (bounds_size)
- o = mono_gc_alloc_array (vtable, byte_len, len, bounds_size);
+ o = (MonoObject *)mono_gc_alloc_array (vtable, byte_len, len, bounds_size);
else
- o = mono_gc_alloc_vector (vtable, byte_len, len);
+ o = (MonoObject *)mono_gc_alloc_vector (vtable, byte_len, len);
array = (MonoArray*)o;
bounds = array->bounds;
mono_gc_out_of_memory (MONO_ARRAY_MAX_SIZE);
return NULL;
}
- o = mono_gc_alloc_vector (vtable, byte_len, n);
+ o = (MonoObject *)mono_gc_alloc_vector (vtable, byte_len, n);
ao = (MonoArray*)o;
return ao;
vtable = mono_class_vtable (domain, mono_defaults.string_class);
g_assert (vtable);
- s = mono_gc_alloc_string (vtable, size, len);
+ s = (MonoString *)mono_gc_alloc_string (vtable, size, len);
return s;
}
g_assert (klass->valuetype);
if (mono_class_is_nullable (klass))
- return mono_nullable_box (value, klass);
+ return mono_nullable_box ((guint8 *)value, klass);
vtable = mono_class_vtable (domain, klass);
if (!vtable)
{
MONO_REQ_GC_UNSAFE_MODE;
- LDStrInfo *info = user_data;
+ LDStrInfo *info = (LDStrInfo *)user_data;
if (info->res || domain == info->orig_domain)
return;
- info->res = mono_g_hash_table_lookup (domain->ldstr_table, info->ins);
+ info->res = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, info->ins);
}
#ifdef HAVE_SGEN_GC
int size;
MonoString *news;
size = sizeof (MonoString) + 2 * (mono_string_length (str) + 1);
- news = mono_gc_alloc_pinned_obj (((MonoObject*)str)->vtable, size);
+ news = (MonoString *)mono_gc_alloc_pinned_obj (((MonoObject*)str)->vtable, size);
if (news) {
memcpy (mono_string_chars (news), mono_string_chars (str), mono_string_length (str) * 2);
news->length = mono_string_length (str);
domain = ((MonoObject *)str)->vtable->domain;
ldstr_table = domain->ldstr_table;
ldstr_lock ();
- res = mono_g_hash_table_lookup (ldstr_table, str);
+ res = (MonoString *)mono_g_hash_table_lookup (ldstr_table, str);
if (res) {
ldstr_unlock ();
return res;
s = mono_string_get_pinned (str);
if (s) {
ldstr_lock ();
- res = mono_g_hash_table_lookup (ldstr_table, str);
+ res = (MonoString *)mono_g_hash_table_lookup (ldstr_table, str);
if (res) {
ldstr_unlock ();
return res;
MONO_REQ_GC_UNSAFE_MODE;
if (image->dynamic) {
- MonoString *str = mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL);
+ MonoString *str = (MonoString *)mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL);
return str;
} else {
if (!mono_verifier_verify_string_signature (image, idx, NULL))
}
#endif
ldstr_lock ();
- interned = mono_g_hash_table_lookup (domain->ldstr_table, o);
+ interned = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, o);
ldstr_unlock ();
if (interned)
return interned; /* o will get garbage collected */
o = mono_string_get_pinned (o);
if (o) {
ldstr_lock ();
- interned = mono_g_hash_table_lookup (domain->ldstr_table, o);
+ interned = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, o);
if (!interned) {
mono_g_hash_table_insert (domain->ldstr_table, o, o);
interned = o;
/* g_utf16_to_utf8 may not be able to complete the convertion (e.g. NULL values were found, #335488) */
if (s->length > written) {
/* allocate the total length and copy the part of the string that has been converted */
- char *as2 = g_malloc0 (s->length);
+ char *as2 = (char *)g_malloc0 (s->length);
memcpy (as2, as, written);
g_free (as);
as = as2;
/* g_utf16_to_utf8 may not be able to complete the convertion (e.g. NULL values were found, #335488) */
if (s->length > written) {
/* allocate the total length and copy the part of the string that has been converted */
- char *as2 = g_malloc0 (s->length);
+ char *as2 = (char *)g_malloc0 (s->length);
memcpy (as2, as, written);
g_free (as);
as = as2;
if (s == NULL)
return NULL;
- as = g_malloc ((s->length * 2) + 2);
+ as = (char *)g_malloc ((s->length * 2) + 2);
as [(s->length * 2)] = '\0';
as [(s->length * 2) + 1] = '\0';
len = strlen (r) + 1;
if (mp)
- mp_s = mono_mempool_alloc (mp, len);
+ mp_s = (char *)mono_mempool_alloc (mp, len);
else
- mp_s = mono_image_alloc (image, len);
+ mp_s = (char *)mono_image_alloc (image, len);
memcpy (mp_s, r, len);
domain->capture_context_method = mono_compile_method (method);
}
- runtime_invoke = domain->capture_context_runtime_invoke;
+ runtime_invoke = (RuntimeInvokeFunction)domain->capture_context_runtime_invoke;
return runtime_invoke (NULL, NULL, NULL, domain->capture_context_method);
}
/* note: result may be null if the flow is suppressed */
}
- res->data = data;
+ res->data = (void **)data;
MONO_OBJECT_SETREF (res, object_data, object_data);
MONO_OBJECT_SETREF (res, async_state, state);
if (handle != NULL)
for (i = 0, j = 0; i < sig->param_count; i++) {
if (sig->params [i]->byref) {
if (out_args) {
- MonoObject* arg = mono_array_get (out_args, gpointer, j);
+ MonoObject* arg = (MonoObject *)mono_array_get (out_args, gpointer, j);
mono_array_setref (this_obj->args, i, arg);
j++;
}
for (i = 0, j = 0; i < sig->param_count; i++) {
if (sig->params [i]->byref) {
MonoObject* arg;
- arg = mono_array_get (msg->args, gpointer, i);
+ arg = (MonoObject *)mono_array_get (msg->args, gpointer, i);
mono_array_setref (*out_args, j, arg);
j++;
}
g_assert (addr);
- ji = mono_jit_info_table_find (domain, mono_get_addr_from_ftnptr (addr));
+ ji = mono_jit_info_table_find (domain, (char *)mono_get_addr_from_ftnptr (addr));
/* Shared code */
if (!ji && domain != mono_get_root_domain ())
- ji = mono_jit_info_table_find (mono_get_root_domain (), mono_get_addr_from_ftnptr (addr));
+ ji = mono_jit_info_table_find (mono_get_root_domain (), (char *)mono_get_addr_from_ftnptr (addr));
if (ji) {
method = mono_jit_info_get_method (ji);
g_assert (!method->klass->generic_container);
if (j >= out_len)
mono_raise_exception (mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments"));
- arg = mono_array_get (out_args, gpointer, j);
+ arg = (char *)mono_array_get (out_args, gpointer, j);
type = pt->type;
g_assert (type != MONO_TYPE_VOID);
const mono_byte *p = *ip;
if (p >= end)
- return -1;
+ return (MonoOpcodeEnum)-1;
if (*p == 0xfe) {
++p;
if (p >= end)
- return -1;
- res = *p + MONO_PREFIX1_OFFSET;
+ return (MonoOpcodeEnum)-1;
+ res = (MonoOpcodeEnum)(*p + MONO_PREFIX1_OFFSET);
} else if (*p == MONO_CUSTOM_PREFIX) {
++p;
if (p >= end)
- return -1;
- res = *p + MONO_CUSTOM_PREFIX_OFFSET;
+ return (MonoOpcodeEnum)-1;
+ res = (MonoOpcodeEnum)(*p + MONO_CUSTOM_PREFIX_OFFSET);
} else {
- res = *p;
+ res = (MonoOpcodeEnum)*p;
}
*ip = p;
return res;
static void
dump_dotnet_iinfo (MonoImage *image)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
dump_dotnet_header (&iinfo->cli_header);
dump_sections (iinfo);
}
for (tmp = errors; tmp; tmp = tmp->next) {
- MonoVerifyInfo *info = tmp->data;
+ MonoVerifyInfo *info = (MonoVerifyInfo *)tmp->data;
g_print ("%s: %s\n", desc [info->status], info->message);
if (info->status == MONO_VERIFY_ERROR) {
count++;
invalid_image:
for (tmp = errors; tmp; tmp = tmp->next) {
- MonoVerifyInfo *info = tmp->data;
+ MonoVerifyInfo *info = (MonoVerifyInfo *)tmp->data;
g_print ("%s: %s\n", desc [info->status], info->message);
if (info->status == MONO_VERIFY_ERROR)
count++;
GList *tmp;
for (tmp = loaded_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (mono_assembly_names_equal (aname, &ass->aname))
return ass;
}
assemblies = g_ptr_array_new ();
mono_domain_assemblies_lock (domain);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (ass->image->fileio_used)
continue;
g_ptr_array_add (assemblies, ass);
if (assemblies) {
for (i = 0; i < assembly_count; i++) {
- MonoAssembly *ass = g_ptr_array_index (assemblies, i);
+ MonoAssembly *ass = (MonoAssembly *)g_ptr_array_index (assemblies, i);
MonoObject *module = get_process_module (ass, proc_class);
mono_array_setref (temp_arr, num_added++, module);
}
gboolean ret;
shellex.cbSize = sizeof(SHELLEXECUTEINFO);
- shellex.fMask = SEE_MASK_FLAG_DDEWAIT | SEE_MASK_NOCLOSEPROCESS | SEE_MASK_UNICODE;
- shellex.nShow = proc_start_info->window_style;
- shellex.nShow = (shellex.nShow == 0) ? 1 : (shellex.nShow == 1 ? 0 : shellex.nShow);
+ shellex.fMask = (WapiShellExecuteInfoFlags)(SEE_MASK_FLAG_DDEWAIT | SEE_MASK_NOCLOSEPROCESS | SEE_MASK_UNICODE);
+ shellex.nShow = (WapiShellExecuteShowFlags)proc_start_info->window_style;
+ shellex.nShow = (WapiShellExecuteShowFlags)((shellex.nShow == 0) ? 1 : (shellex.nShow == 1 ? 0 : shellex.nShow));
if (proc_start_info->filename != NULL) {
if (proc_start_info->error_dialog) {
shellex.hwnd = proc_start_info->error_dialog_parent_handle;
} else {
- shellex.fMask |= SEE_MASK_FLAG_NO_UI;
+ shellex.fMask = (WapiShellExecuteInfoFlags)(shellex.fMask | SEE_MASK_FLAG_NO_UI);
}
ret = ShellExecuteEx (&shellex);
if (process_info->username) {
logon_flags = process_info->load_user_profile ? LOGON_WITH_PROFILE : 0;
- ret=CreateProcessWithLogonW (mono_string_chars (process_info->username), process_info->domain ? mono_string_chars (process_info->domain) : NULL, process_info->password, logon_flags, shell_path, cmd? mono_string_chars (cmd): NULL, creation_flags, env_vars, dir, &startinfo, &procinfo);
+ ret = CreateProcessWithLogonW (
+ mono_string_chars (process_info->username),
+ process_info->domain ? mono_string_chars (process_info->domain) : NULL,
+ (const gunichar2 *)process_info->password, logon_flags, shell_path,
+ cmd ? mono_string_chars (cmd) : NULL,
+ creation_flags, env_vars, dir, &startinfo, &procinfo);
} else {
ret=CreateProcess (shell_path, cmd? mono_string_chars (cmd): NULL, NULL, NULL, TRUE, creation_flags, env_vars, dir, &startinfo, &procinfo);
}
MonoProcessError perror;
guint64 res;
- res = mono_process_get_data_with_error (GINT_TO_POINTER (pid), data_type, &perror);
+ res = mono_process_get_data_with_error (GINT_TO_POINTER (pid), (MonoProcessData)data_type, &perror);
if (error)
*error = perror;
return res;
mono_profiler_set_events (MonoProfileFlags events)
{
ProfilerDesc *prof;
- MonoProfileFlags value = 0;
+ MonoProfileFlags value = (MonoProfileFlags)0;
if (prof_list)
prof_list->events = events;
for (prof = prof_list; prof; prof = prof->next)
- value |= prof->events;
+ value = (MonoProfileFlags)(value | prof->events);
mono_profiler_events = value;
}
prof->shutdown_callback (prof->profiler);
}
- mono_profiler_set_events (0);
+ mono_profiler_set_events ((MonoProfileFlags)0);
}
void
if (!coverage_hash)
coverage_hash = g_hash_table_new (NULL, NULL);
- res = g_malloc0 (sizeof (MonoProfileCoverageInfo) + sizeof (void*) * 2 * entries);
+ res = (MonoProfileCoverageInfo *)g_malloc0 (sizeof (MonoProfileCoverageInfo) + sizeof (void*) * 2 * entries);
res->entries = entries;
return;
}
- info = g_hash_table_lookup (coverage_hash, method);
+ info = (MonoProfileCoverageInfo *)g_hash_table_lookup (coverage_hash, method);
if (info) {
g_free (info);
g_hash_table_remove (coverage_hash, method);
mono_profiler_coverage_lock ();
if (coverage_hash)
- info = g_hash_table_lookup (coverage_hash, method);
+ info = (MonoProfileCoverageInfo *)g_hash_table_lookup (coverage_hash, method);
mono_profiler_coverage_unlock ();
if (!info)
gboolean res = FALSE;
if (col != NULL) {
- mname = g_memdup (desc, col - desc + 1);
+ mname = (char *)g_memdup (desc, col - desc + 1);
mname [col - desc] = 0;
} else {
mname = g_strdup (desc);
static guint32 create_typespec (MonoDynamicImage *assembly, MonoType *type);
static void init_type_builder_generics (MonoObject *type);
-#define RESOLVE_TYPE(type) do { type = (void*)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type); } while (0)
+#define RESOLVE_TYPE(type) do { type = (MonoObject *)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type); } while (0)
#define RESOLVE_ARRAY_TYPE_ELEMENT(array, index) do { \
MonoReflectionType *__type = mono_array_get (array, MonoReflectionType*, index); \
__type = mono_reflection_type_resolve_user_types (__type); \
if (dynamic_images)
{
for (i = 0; !owner && i < dynamic_images->len; ++i) {
- MonoImage *image = g_ptr_array_index (dynamic_images, i);
+ MonoImage *image = (MonoImage *)g_ptr_array_index (dynamic_images, i);
if (mono_mempool_contains_addr (image->mempool, ptr))
owner = image;
}
MonoObject *obj;
dynamic_image_lock (assembly);
- obj = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ obj = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
dynamic_image_unlock (assembly);
return obj;
{
MONO_REQ_GC_NEUTRAL_MODE;
- buf->buf = g_malloc (size);
+ buf->buf = (char *)g_malloc (size);
buf->p = buf->buf;
buf->end = buf->buf + size;
}
if (buf->end - buf->p < size) {
int new_size = buf->end - buf->buf + size + 32;
- char *p = g_realloc (buf->buf, new_size);
+ char *p = (char *)g_realloc (buf->buf, new_size);
size = buf->p - buf->buf;
buf->buf = p;
buf->p = p + size;
table->alloc_rows *= 2;
}
- table->values = g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
+ table->values = (guint32 *)g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
}
}
stream->alloc_size *= 2;
}
- stream->data = g_realloc (stream->data, stream->alloc_size);
+ stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
}
static guint32
sh->index = 0;
sh->alloc_size = 4096;
- sh->data = g_malloc (4096);
+ sh->data = (char *)g_malloc (4096);
sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
string_heap_insert (sh, "");
}
char *copy;
gpointer oldkey, oldval;
- copy = g_malloc (s1+s2);
+ copy = (char *)g_malloc (s1+s2);
memcpy (copy, b1, s1);
memcpy (copy + s1, b2, s2);
if (g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
MonoCustomAttrInfo* res;
- res = mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
+ res = (MonoCustomAttrInfo *)mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
if (!res)
return NULL;
- res = g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
+ res = (MonoCustomAttrInfo *)g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
res->cached = 0;
return res;
}
}
count -= not_visible;
- ainfo = image_g_malloc0 (alloc_img, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * count);
+ ainfo = (MonoCustomAttrInfo *)image_g_malloc0 (alloc_img, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * count);
ainfo->image = image;
ainfo->num_attrs = count;
for (i = 0; i < count; ++i) {
cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
if (custom_attr_visible (image, cattr)) {
- unsigned char *saved = mono_image_alloc (image, mono_array_length (cattr->data));
+ unsigned char *saved = (unsigned char *)mono_image_alloc (image, mono_array_length (cattr->data));
memcpy (saved, mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
ainfo->attrs [index].ctor = cattr->ctor->method;
ainfo->attrs [index].data = saved;
ainfo = mono_custom_attrs_from_builders (image, image, cattrs);
mono_loader_lock ();
- tmp = mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
+ tmp = (MonoCustomAttrInfo *)mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
if (tmp)
mono_custom_attrs_free (tmp);
mono_image_property_insert (image, obj, MONO_PROP_DYNAMIC_CATTR, ainfo);
guint32 owner = MONO_TYPEORMETHOD_METHOD | (mb->table_idx << MONO_TYPEORMETHOD_BITS);
mono_image_get_generic_param_info (
- mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
+ (MonoReflectionGenericParam *)mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
}
}
}
static guint32
-encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type)
+encode_constant (MonoDynamicImage *assembly, MonoObject *val, MonoTypeEnum *ret_type)
{
MONO_REQ_GC_UNSAFE_MODE;
char* buf;
guint32 idx = 0, len = 0, dummy = 0;
- buf = g_malloc (64);
+ buf = (char *)g_malloc (64);
if (!val) {
*ret_type = MONO_TYPE_CLASS;
len = 4;
values [MONO_FIELD_LAYOUT_OFFSET] = fb->offset;
}
if (fb->attrs & FIELD_ATTRIBUTE_LITERAL) {
- guint32 field_type = 0;
+ MonoTypeEnum field_type = (MonoTypeEnum)0;
table = &assembly->tables [MONO_TABLE_CONSTANT];
table->rows ++;
alloc_table (table, table->rows);
values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
}
if (pb->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT) {
- guint32 field_type = 0;
+ MonoTypeEnum field_type = (MonoTypeEnum)0;
table = &assembly->tables [MONO_TABLE_CONSTANT];
table->rows ++;
alloc_table (table, table->rows);
}
for (i = 0; i < num_constraints; i++) {
- MonoReflectionType *constraint = mono_array_get (
+ MonoReflectionType *constraint = (MonoReflectionType *)mono_array_get (
gparam->iface_constraints, gpointer, i);
table_idx = table->next_idx ++;
*/
if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
(type->type != MONO_TYPE_MVAR)) {
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
- register_dyn_token (assembly, token, mono_class_get_ref_info (klass));
+ register_dyn_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
return token;
}
token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
table->next_idx ++;
- register_dyn_token (assembly, token, mono_class_get_ref_info (klass));
+ register_dyn_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
return token;
}
type_argv = g_new0 (MonoType *, count);
for (i = 0; i < count; i++) {
- MonoReflectionType *garg = mono_array_get (m->method_args, gpointer, i);
+ MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (m->method_args, gpointer, i);
type_argv [i] = mono_reflection_type_get_handle (garg);
}
ginst = mono_metadata_get_generic_inst (count, type_argv);
return mono_metadata_type_dup (NULL, type);
len = MONO_SIZEOF_TYPE + ((gint32)count) * sizeof (MonoCustomMod);
- t = g_malloc (len);
+ t = (MonoType *)g_malloc (len);
memcpy (t, type, MONO_SIZEOF_TYPE);
t->num_mods = count;
name = mono_string_to_utf8 (m->name);
nparams = mono_array_length (m->parameters);
- sig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * nparams);
+ sig = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * nparams);
sig->hasthis = 1;
sig->sentinelpos = -1;
sig->call_convention = reflection_cc_to_file (m->call_conv);
sig->params [i] = mono_type_array_get_and_resolve (m->parameters, i);
for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
- am = tmp->data;
+ am = (ArrayMethod *)tmp->data;
if (strcmp (name, am->name) == 0 &&
mono_metadata_type_equal (am->parent, mtype) &&
mono_metadata_signature_equal (am->sig, sig)) {
GList *tmp;
for (tmp = klass->ext->nested_classes; tmp; tmp = tmp->next)
- mono_image_fill_export_table_from_class (domain, tmp->data, module_index, table->next_idx - 1, assembly);
+ mono_image_fill_export_table_from_class (domain, (MonoClass *)tmp->data, module_index, table->next_idx - 1, assembly);
}
return res;
static int
compare_constants (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_CONSTANT_PARENT] - b_values [MONO_CONSTANT_PARENT];
}
static int
compare_semantics (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
int assoc = a_values [MONO_METHOD_SEMA_ASSOCIATION] - b_values [MONO_METHOD_SEMA_ASSOCIATION];
if (assoc)
return assoc;
static int
compare_custom_attrs (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_CUSTOM_ATTR_PARENT] - b_values [MONO_CUSTOM_ATTR_PARENT];
}
static int
compare_field_marshal (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_FIELD_MARSHAL_PARENT] - b_values [MONO_FIELD_MARSHAL_PARENT];
}
static int
compare_nested (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_NESTED_CLASS_NESTED] - b_values [MONO_NESTED_CLASS_NESTED];
}
static int
compare_declsecurity_attrs (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_DECL_SECURITY_PARENT] - b_values [MONO_DECL_SECURITY_PARENT];
}
static int
compare_interface_impl (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
int klass = a_values [MONO_INTERFACEIMPL_CLASS] - b_values [MONO_INTERFACEIMPL_CLASS];
if (klass)
qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
for (i = 0; i < assembly->gen_params->len; i++){
- GenericParamTableEntry *entry = g_ptr_array_index (assembly->gen_params, i);
+ GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (assembly->gen_params, i);
write_generic_param_entry (assembly, entry);
}
heapt_size += 3;
heapt_size &= ~3;
meta_size += heapt_size;
- meta->raw_metadata = g_malloc0 (meta_size);
+ meta->raw_metadata = (char *)g_malloc0 (meta_size);
p = (unsigned char*)meta->raw_metadata;
/* the metadata signature */
*p++ = 'B'; *p++ = 'S'; *p++ = 'J'; *p++ = 'B';
if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
- ctor = mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
+ ctor = (MonoObject *)mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
g_assert (ctor);
if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
token = mono_image_add_stream_data (&assembly->blob, blob_size, b - blob_size);
mono_image_add_stream_data (&assembly->blob, mono_array_addr (pkey, char, 0), len);
- assembly->public_key = g_malloc (len);
+ assembly->public_key = (guint8 *)g_malloc (len);
memcpy (assembly->public_key, mono_array_addr (pkey, char, 0), len);
assembly->public_key_len = len;
g_warning ("Invalid public key length: %d bits (total: %d)", (int)MONO_PUBLIC_KEY_BIT_SIZE (len), (int)len);
assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH; /* to be safe */
}
- assembly->strong_name = g_malloc0 (assembly->strong_name_size);
+ assembly->strong_name = (char *)g_malloc0 (assembly->strong_name_size);
return token;
}
collect_types (&types, type);
}
- mono_ptr_array_sort (types, (gpointer)compare_types_by_table_idx);
+ mono_ptr_array_sort (types, (int (*)(const void *, const void *))compare_types_by_table_idx);
table = &assembly->tables [MONO_TABLE_TYPEDEF];
table->rows += mono_ptr_array_size (types);
alloc_table (table, table->rows);
* so load_class_names () needs to touch fewer pages.
*/
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *tb = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
string_heap_insert_mstring (&assembly->sheap, tb->nspace);
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *tb = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
string_heap_insert_mstring (&assembly->sheap, tb->name);
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *type = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
mono_image_get_type_info (domain, type, assembly);
}
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *type = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
if (type->methods) {
for (j = 0; j < type->num_methods; ++j) {
MonoReflectionMethodBuilder *mb = mono_array_get (
MonoObject *prev;
dynamic_image_lock (assembly);
- prev = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ prev = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
if (prev) {
/* There could be multiple MethodInfo objects with the same token */
//g_assert (prev == obj);
#if HAVE_BOEHM_GC
/* The MonoGHashTable's need GC tracking */
- image = GC_MALLOC (sizeof (MonoDynamicImage));
+ image = (MonoDynamicImage *)GC_MALLOC (sizeof (MonoDynamicImage));
#else
image = g_new0 (MonoDynamicImage, 1);
#endif
g_list_free (di->array_methods);
if (di->gen_params) {
for (i = 0; i < di->gen_params->len; i++) {
- GenericParamTableEntry *entry = g_ptr_array_index (di->gen_params, i);
+ GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (di->gen_params, i);
mono_gc_deregister_root ((char*) &entry->gparam);
g_free (entry);
}
#if HAVE_BOEHM_GC
/* assembly->assembly.image might be GC allocated */
- assembly = assemblyb->dynamic_assembly = GC_MALLOC (sizeof (MonoDynamicAssembly));
+ assembly = assemblyb->dynamic_assembly = (MonoDynamicAssembly *)GC_MALLOC (sizeof (MonoDynamicAssembly));
#else
assembly = assemblyb->dynamic_assembly = g_new0 (MonoDynamicAssembly, 1);
#endif
}
/* Directory structure */
size += mono_array_length (assemblyb->win32_resources) * 256;
- p = buf = g_malloc (size);
+ p = buf = (char *)g_malloc (size);
resource_tree_encode (tree, p, p, &p);
g_assert (p - buf <= size);
- assembly->win32_res = g_malloc (p - buf);
+ assembly->win32_res = (char *)g_malloc (p - buf);
assembly->win32_res_size = p - buf;
memcpy (assembly->win32_res, buf, p - buf);
static gboolean
reflected_equal (gconstpointer a, gconstpointer b) {
- const ReflectedEntry *ea = a;
- const ReflectedEntry *eb = b;
+ const ReflectedEntry *ea = (const ReflectedEntry *)a;
+ const ReflectedEntry *eb = (const ReflectedEntry *)b;
return (ea->item == eb->item) && (ea->refclass == eb->refclass);
}
static guint
reflected_hash (gconstpointer a) {
- const ReflectedEntry *ea = a;
+ const ReflectedEntry *ea = (const ReflectedEntry *)a;
return mono_aligned_addr_hash (ea->item);
}
mono_domain_lock (domain); \
if (!domain->refobject_hash) \
domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table"); \
- if ((_obj = mono_g_hash_table_lookup (domain->refobject_hash, &e))) { \
+ if ((_obj = (t)mono_g_hash_table_lookup (domain->refobject_hash, &e))) { \
mono_domain_unlock (domain); \
return _obj; \
} \
#define FREE_REFENTRY(entry) g_free ((entry))
#define REFENTRY_REQUIRES_CLEANUP
#else
-#define ALLOC_REFENTRY mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
+#define ALLOC_REFENTRY (ReflectedEntry *)mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
/* FIXME: */
#define FREE_REFENTRY(entry)
#endif
mono_domain_lock (domain); \
if (!domain->refobject_hash) \
domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table"); \
- _obj = mono_g_hash_table_lookup (domain->refobject_hash, &pe); \
+ _obj = (t)mono_g_hash_table_lookup (domain->refobject_hash, &pe); \
if (!_obj) { \
ReflectedEntry *e = ALLOC_REFENTRY; \
e->item = (p); \
if (type == &klass->byval_arg && !image_is_dynamic (klass->image)) {
MonoVTable *vtable = mono_class_try_get_vtable (domain, klass);
if (vtable && vtable->type)
- return vtable->type;
+ return (MonoReflectionType *)vtable->type;
}
mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
if (!domain->type_hash)
domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
(GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table");
- if ((res = mono_g_hash_table_lookup (domain->type_hash, type))) {
+ if ((res = (MonoReflectionType *)mono_g_hash_table_lookup (domain->type_hash, type))) {
mono_domain_unlock (domain);
mono_loader_unlock ();
return res;
if (is_type_done && !type->byref) {
mono_domain_unlock (domain);
mono_loader_unlock ();
- return mono_class_get_ref_info (klass);
+ return (MonoReflectionType *)mono_class_get_ref_info (klass);
}
}
/* This is stored in vtables/JITted code so it has to be pinned */
/* Build MonoType for the type from the Constant Table */
if (!type)
type = g_new0 (MonoType, 1);
- type->type = types [i];
+ type->type = (MonoTypeEnum)types [i];
type->data.klass = NULL;
if (types [i] == MONO_TYPE_CLASS)
type->data.klass = mono_defaults.object_class;
MonoReflectionMethodAux *aux;
if (method->is_inflated)
method = ((MonoMethodInflated*)method)->declaring;
- aux = g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
+ aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (aux && aux->param_defaults) {
memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
memcpy (types, &(aux->param_default_types [1]), methodsig->param_count * sizeof (guint32));
}
mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
- blobs [paramseq - 1] = (gpointer) mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
+ blobs [paramseq - 1] = (char *)mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
types [paramseq - 1] = const_cols [MONO_CONSTANT_TYPE];
}
char *nested_name, *nested_nspace;
gboolean match = TRUE;
- lastp = strrchr (mod->data, '.');
+ lastp = strrchr ((const char *)mod->data, '.');
if (lastp) {
/* Nested classes can have namespaces */
int nspace_len;
nested_name = g_strdup (lastp + 1);
nspace_len = lastp - (char*)mod->data;
- nested_nspace = g_malloc (nspace_len + 1);
+ nested_nspace = (char *)g_malloc (nspace_len + 1);
memcpy (nested_nspace, mod->data, nspace_len);
nested_nspace [nspace_len] = '\0';
} else {
- nested_name = mod->data;
+ nested_name = (char *)mod->data;
nested_nspace = NULL;
}
int i;
for (i = 0; i < info->type_arguments->len; i++) {
- MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
+ MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
if (!type_args [i]) {
int i;
for (i = 0; i < info->type_arguments->len; i++) {
- MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
+ MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
mono_reflection_free_type_info (subinfo);
/*We free the subinfo since it is allocated by _mono_reflection_parse_type*/
mono_error_init (error);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, image);
if (!t) {
case MONO_TYPE_U1:
case MONO_TYPE_I1:
case MONO_TYPE_BOOLEAN: {
- MonoBoolean *bval = g_malloc (sizeof (MonoBoolean));
+ MonoBoolean *bval = (MonoBoolean *)g_malloc (sizeof (MonoBoolean));
*bval = *p;
*end = p + 1;
return bval;
case MONO_TYPE_CHAR:
case MONO_TYPE_U2:
case MONO_TYPE_I2: {
- guint16 *val = g_malloc (sizeof (guint16));
+ guint16 *val = (guint16 *)g_malloc (sizeof (guint16));
*val = read16 (p);
*end = p + 2;
return val;
case MONO_TYPE_R4:
case MONO_TYPE_U4:
case MONO_TYPE_I4: {
- guint32 *val = g_malloc (sizeof (guint32));
+ guint32 *val = (guint32 *)g_malloc (sizeof (guint32));
*val = read32 (p);
*end = p + 4;
return val;
#endif
case MONO_TYPE_U8:
case MONO_TYPE_I8: {
- guint64 *val = g_malloc (sizeof (guint64));
+ guint64 *val = (guint64 *)g_malloc (sizeof (guint64));
*val = read64 (p);
*end = p + 8;
return val;
}
case MONO_TYPE_R8: {
- double *val = g_malloc (sizeof (double));
+ double *val = (double *)g_malloc (sizeof (double));
readr8 (p, val);
*end = p + 8;
return val;
MonoClass *k = t->data.klass;
if (mono_is_corlib_image (k->image) && strcmp (k->name_space, "System") == 0 && strcmp (k->name, "DateTime") == 0){
- guint64 *val = g_malloc (sizeof (guint64));
+ guint64 *val = (guint64 *)g_malloc (sizeof (guint64));
*val = read64 (p);
*end = p + 8;
return val;
}
handle_type:
slen = mono_metadata_decode_value (p, &p);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, image);
if (!t) {
if (etype == 0x51)
/* See Partition II, Appendix B3 */
etype = MONO_TYPE_OBJECT;
- simple_type.type = etype;
+ simple_type.type = (MonoTypeEnum)etype;
tklass = mono_class_from_mono_type (&simple_type);
}
goto handle_enum;
char *n;
MonoType *t;
slen = mono_metadata_decode_value (p, &p);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, image);
if (!t) {
subc = mono_class_from_mono_type (t);
} else if (subt >= MONO_TYPE_BOOLEAN && subt <= MONO_TYPE_R8) {
MonoType simple_type = {{0}};
- simple_type.type = subt;
+ simple_type.type = (MonoTypeEnum)subt;
subc = mono_class_from_mono_type (&simple_type);
} else {
g_error ("Unknown type 0x%02x for object type encoding in custom attr", subt);
case MONO_TYPE_STRING:
case MONO_TYPE_SZARRAY:
for (i = 0; i < alen; i++) {
- MonoObject *item = load_cattr_value (image, &tklass->byval_arg, p, &p, error);
+ MonoObject *item = (MonoObject *)load_cattr_value (image, &tklass->byval_arg, p, &p, error);
if (!mono_error_ok (error))
return NULL;
mono_array_setref (arr, i, item);
memset (params, 0, sizeof (void*) * sig->param_count);
} else {
/* Allocate using GC so it gets GC tracking */
- params = mono_gc_alloc_fixed (sig->param_count * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_REFLECTION, "custom attribute parameters");
+ params = (void **)mono_gc_alloc_fixed (sig->param_count * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_REFLECTION, "custom attribute parameters");
}
/* skip prolog */
gint type_len;
char *type_name;
type_len = mono_metadata_decode_blob_size (named, &named);
- type_name = g_malloc (type_len + 1);
+ type_name = (char *)g_malloc (type_len + 1);
memcpy (type_name, named, type_len);
type_name [type_len] = 0;
named += type_len;
g_free (type_name);
}
name_len = mono_metadata_decode_blob_size (named, &named);
- name = g_malloc (name_len + 1);
+ name = (char *)g_malloc (name_len + 1);
memcpy (name, named, name_len);
name [name_len] = 0;
named += name_len;
return;
}
- obj = type_is_reference (mono_method_signature (method)->params [i]) ?
- val : mono_value_box (domain, mono_class_from_mono_type (mono_method_signature (method)->params [i]), val);
+ obj = (MonoObject *)(type_is_reference (mono_method_signature (method)->params [i]) ?
+ val : mono_value_box (domain, mono_class_from_mono_type (mono_method_signature (method)->params [i]), val));
mono_array_setref (typedargs, i, obj);
if (!type_is_reference (mono_method_signature (method)->params [i]))
if (ADDP_IS_GREATER_OR_OVF ((const guchar*)named, type_len, data + len))
goto fail;
- type_name = g_malloc (type_len + 1);
+ type_name = (char *)g_malloc (type_len + 1);
memcpy (type_name, named, type_len);
type_name [type_len] = 0;
named += type_len;
name_len = mono_metadata_decode_blob_size (named, &named);
if (ADDP_IS_GREATER_OR_OVF ((const guchar*)named, name_len, data + len))
goto fail;
- name = g_malloc (name_len + 1);
+ name = (char *)g_malloc (name_len + 1);
memcpy (name, named, name_len);
name [name_len] = 0;
named += name_len;
return;
}
- obj = type_is_reference (field->type) ? val : mono_value_box (domain, mono_class_from_mono_type (field->type), val);
+ obj = (MonoObject *)(type_is_reference (field->type) ? val : mono_value_box (domain, mono_class_from_mono_type (field->type), val));
mono_array_setref (namedargs, j, obj);
if (!type_is_reference (field->type))
g_free (val);
return;
}
- obj = type_is_reference (prop_type) ? val : mono_value_box (domain, mono_class_from_mono_type (prop_type), val);
+ obj = (MonoObject *)(type_is_reference (prop_type) ? val : mono_value_box (domain, mono_class_from_mono_type (prop_type), val));
mono_array_setref (namedargs, j, obj);
if (!type_is_reference (prop_type))
g_free (val);
if (!mono_class_init (method->klass))
mono_raise_exception (mono_class_get_exception_for_failure (method->klass));
- mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo, &error);
+ mono_reflection_create_custom_attr_data_args (image, method, (const guchar *)data, len, &typedargs, &namedargs, &arginfo, &error);
if (!mono_error_ok (&error))
mono_error_raise_exception (&error);
if (mono_loader_get_last_error ())
len = g_list_length (list);
if (!len)
return NULL;
- ainfo = g_malloc0 (MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * len);
+ ainfo = (MonoCustomAttrInfo *)g_malloc0 (MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * len);
ainfo->num_attrs = len;
ainfo->image = image;
for (i = len, tmp = list; i != 0; --i, tmp = tmp->next) {
MonoCustomAttrInfo *res, *ainfo;
int size;
- aux = g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
+ aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (!aux || !aux->param_cattr)
return NULL;
if (!ainfo)
return NULL;
size = MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * ainfo->num_attrs;
- res = g_malloc0 (size);
+ res = (MonoCustomAttrInfo *)g_malloc0 (size);
memcpy (res, ainfo, size);
return res;
}
count = mono_array_length (gclass->type_arguments);
types = g_new0 (MonoType*, count);
for (i = 0; i < count; ++i) {
- MonoReflectionType *t = mono_array_get (gclass->type_arguments, gpointer, i);
+ MonoReflectionType *t = (MonoReflectionType *)mono_array_get (gclass->type_arguments, gpointer, i);
types [i] = mono_reflection_type_get_handle (t);
if (!types[i]) {
g_free (types);
count = parameters? mono_array_length (parameters): 0;
- sig = image_g_malloc0 (image, MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * count);
+ sig = (MonoMethodSignature *)image_g_malloc0 (image, MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * count);
sig->param_count = count;
sig->sentinelpos = -1; /* FIXME */
for (i = 0; i < count; ++i)
if ((p-buffer) + 10 >= *buflen) {
char *newbuf;
*buflen *= 2;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += slen;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += slen;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += slen;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += len;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
g_assert (mono_array_length (ctorArgs) == sig->param_count);
buflen = 256;
- p = buffer = g_malloc (buflen);
+ p = buffer = (char *)g_malloc (buflen);
/* write the prolog */
*p++ = 1;
*p++ = 0;
MonoType *ptype;
char *pname;
- prop = mono_array_get (properties, gpointer, i);
+ prop = (MonoObject *)mono_array_get (properties, gpointer, i);
get_prop_name_and_type (prop, &pname, &ptype);
*p++ = 0x54; /* PROPERTY signature */
encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ptype, pname, (MonoObject*)mono_array_get (propValues, gpointer, i));
MonoType *ftype;
char *fname;
- field = mono_array_get (fields, gpointer, i);
+ field = (MonoObject *)mono_array_get (fields, gpointer, i);
get_field_name_and_type (field, &fname, &ftype);
*p++ = 0x53; /* FIELD signature */
encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ftype, fname, (MonoObject*)mono_array_get (fieldValues, gpointer, i));
return;
}
- klass = mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
+ klass = (MonoClass *)mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
klass->image = &tb->module->dynamic_image->image;
g_assert (tb->generic_container && (tb->generic_container->owner.klass == klass));
- klass->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
+ klass->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
klass->generic_container->owner.klass = klass;
klass->generic_container->type_argc = count;
- klass->generic_container->type_params = mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
+ klass->generic_container->type_params = (MonoGenericParamFull *)mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
klass->is_generic = 1;
for (i = 0; i < count; i++) {
- MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i);
+ MonoReflectionGenericParam *gparam = (MonoReflectionGenericParam *)mono_array_get (tb->generic_params, gpointer, i);
MonoGenericParamFull *param = (MonoGenericParamFull *) mono_reflection_type_get_handle ((MonoReflectionType*)gparam)->data.generic_param;
klass->generic_container->type_params [i] = *param;
/*Make sure we are a diferent type instance */
MonoMarshalSpec *res;
res = image_g_new0 (image, MonoMarshalSpec, 1);
- res->native = minfo->type;
+ res->native = (MonoMarshalNative)minfo->type;
switch (minfo->type) {
case MONO_NATIVE_LPARRAY:
- res->data.array_data.elem_type = minfo->eltype;
+ res->data.array_data.elem_type = (MonoMarshalNative)minfo->eltype;
if (minfo->has_size) {
res->data.array_data.param_num = minfo->param_num;
res->data.array_data.num_elem = minfo->count;
}
}
- header = image_g_malloc0 (image, MONO_SIZEOF_METHOD_HEADER + num_locals * sizeof (MonoType*));
+ header = (MonoMethodHeader *)image_g_malloc0 (image, MONO_SIZEOF_METHOD_HEADER + num_locals * sizeof (MonoType*));
header->code_size = code_size;
- header->code = image_g_malloc (image, code_size);
+ header->code = (const unsigned char *)image_g_malloc (image, code_size);
memcpy ((char*)header->code, code, code_size);
header->max_stack = max_stack;
header->init_locals = rmb->init_locals;
if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
MonoDynamicImage *assembly;
- guint32 idx, def_type, len;
+ guint32 idx, len;
+ MonoTypeEnum def_type;
char *p;
const char *p2;
p = assembly->blob.data + idx;
len = mono_metadata_decode_blob_size (p, &p2);
len += p2 - p;
- method_aux->param_defaults [i] = image_g_malloc (image, len);
+ method_aux->param_defaults [i] = (uint8_t *)image_g_malloc (image, len);
method_aux->param_default_types [i] = def_type;
memcpy ((gpointer)method_aux->param_defaults [i], p, len);
}
type_argv = g_new0 (MonoType *, count);
for (i = 0; i < count; i++) {
- MonoReflectionType *garg = mono_array_get (types, gpointer, i);
+ MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (types, gpointer, i);
type_argv [i] = mono_reflection_type_get_handle (garg);
}
ginst = mono_metadata_get_generic_inst (count, type_argv);
dgclass->field_generic_types = mono_image_set_new0 (gclass->owner, MonoType*, dgclass->count_fields);
for (i = 0; i < dgclass->count_fields; i++) {
- MonoObject *obj = mono_array_get (fields, gpointer, i);
+ MonoObject *obj = (MonoObject *)mono_array_get (fields, gpointer, i);
MonoClassField *field, *inflated_field = NULL;
if (!strcmp (obj->vtable->klass->name, "FieldBuilder"))
if (klass->method.count != gklass->method.count) {
klass->method.count = gklass->method.count;
- klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
+ klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
for (i = 0; i < klass->method.count; i++) {
MonoError error;
if (klass->interface_count && klass->interface_count != gklass->interface_count) {
klass->interface_count = gklass->interface_count;
- klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * gklass->interface_count);
+ klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * gklass->interface_count);
klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
for (i = 0; i < gklass->interface_count; ++i) {
static void
ensure_runtime_vtable (MonoClass *klass)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
int i, num, j;
if (!image_is_dynamic (klass->image) || (!tb && !klass->generic_class) || klass->wastypebuilder)
num = tb->ctors? mono_array_length (tb->ctors): 0;
num += tb->num_methods;
klass->method.count = num;
- klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
+ klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
num = tb->ctors? mono_array_length (tb->ctors): 0;
for (i = 0; i < num; ++i)
klass->methods [i] = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i));
if (tb->interfaces) {
klass->interface_count = mono_array_length (tb->interfaces);
- klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
+ klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
for (i = 0; i < klass->interface_count; ++i) {
MonoType *iface = mono_type_array_get_and_resolve (tb->interfaces, i);
klass->interfaces [i] = mono_class_from_mono_type (iface);
static void
typebuilder_setup_fields (MonoClass *klass, MonoError *error)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
MonoReflectionFieldBuilder *fb;
MonoClassField *field;
MonoImage *image = klass->image;
for (i = 0; i < klass->field.count; ++i) {
MonoArray *rva_data;
- fb = mono_array_get (tb->fields, gpointer, i);
+ fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
field = &klass->fields [i];
field->name = mono_string_to_utf8_image (image, fb->name, error);
if (!mono_error_ok (error))
if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && (rva_data = fb->rva_data)) {
char *base = mono_array_addr (rva_data, char, 0);
size_t size = mono_array_length (rva_data);
- char *data = mono_image_alloc (klass->image, size);
+ char *data = (char *)mono_image_alloc (klass->image, size);
memcpy (data, base, size);
klass->ext->field_def_values [i].data = data;
}
p = assembly->blob.data + idx;
len = mono_metadata_decode_blob_size (p, &p2);
len += p2 - p;
- klass->ext->field_def_values [i].data = mono_image_alloc (image, len);
+ klass->ext->field_def_values [i].data = (const char *)mono_image_alloc (image, len);
memcpy ((gpointer)klass->ext->field_def_values [i].data, p, len);
}
}
static void
typebuilder_setup_properties (MonoClass *klass, MonoError *error)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
MonoReflectionPropertyBuilder *pb;
MonoImage *image = klass->image;
MonoProperty *properties;
p = assembly->blob.data + idx;
len = mono_metadata_decode_blob_size (p, &p2);
len += p2 - p;
- klass->ext->prop_def_values [i].data = mono_image_alloc (image, len);
+ klass->ext->prop_def_values [i].data = (const char *)mono_image_alloc (image, len);
memcpy ((gpointer)klass->ext->prop_def_values [i].data, p, len);
}
}
static void
typebuilder_setup_events (MonoClass *klass, MonoError *error)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
MonoReflectionEventBuilder *eb;
MonoImage *image = klass->image;
MonoEvent *events;
check_array_for_usertypes (tb->interfaces);
if (tb->fields) {
for (i = 0; i < mono_array_length (tb->fields); ++i) {
- MonoReflectionFieldBuilder *fb = mono_array_get (tb->fields, gpointer, i);
+ MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
if (fb) {
RESOLVE_TYPE (fb->type);
check_array_for_usertypes (fb->modreq);
}
if (tb->methods) {
for (i = 0; i < mono_array_length (tb->methods); ++i) {
- MonoReflectionMethodBuilder *mb = mono_array_get (tb->methods, gpointer, i);
+ MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)mono_array_get (tb->methods, gpointer, i);
if (mb) {
RESOLVE_TYPE (mb->rtype);
check_array_for_usertypes (mb->return_modreq);
}
if (tb->ctors) {
for (i = 0; i < mono_array_length (tb->ctors); ++i) {
- MonoReflectionCtorBuilder *mb = mono_array_get (tb->ctors, gpointer, i);
+ MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)mono_array_get (tb->ctors, gpointer, i);
if (mb) {
check_array_for_usertypes (mb->parameters);
if (mb->param_modreq)
if (!gparam->mbuilder->generic_container) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)gparam->mbuilder->type;
MonoClass *klass = mono_class_from_mono_type (mono_reflection_type_get_handle ((MonoReflectionType*)tb));
- gparam->mbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
+ gparam->mbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->mbuilder->generic_container->is_method = TRUE;
/*
* Cannot set owner.method, since the MonoMethod is not created yet.
} else if (gparam->tbuilder) {
if (!gparam->tbuilder->generic_container) {
MonoClass *klass = mono_class_from_mono_type (mono_reflection_type_get_handle ((MonoReflectionType*)gparam->tbuilder));
- gparam->tbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
+ gparam->tbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->tbuilder->generic_container->owner.klass = klass;
}
param->param.owner = gparam->tbuilder->generic_container;
static void
free_dynamic_method (void *dynamic_method)
{
- DynamicMethodReleaseData *data = dynamic_method;
+ DynamicMethodReleaseData *data = (DynamicMethodReleaseData *)dynamic_method;
MonoDomain *domain = data->domain;
MonoMethod *method = data->handle;
guint32 dis_link;
mono_error_init (error);
- sig = g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
+ sig = (MonoMethodSignature *)g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
if (sig)
return sig;
ensure_complete_type (MonoClass *klass)
{
if (image_is_dynamic (klass->image) && !klass->wastypebuilder && mono_class_get_ref_info (klass)) {
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
result = ((MonoReflectionMethod*)obj)->method;
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
*handle_class = mono_defaults.methodhandle_class;
}
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
*handle_class = mono_defaults.methodhandle_class;
}
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
*handle_class = mono_defaults.methodhandle_class;
result = mono_reflection_method_on_tb_inst_get_handle (m);
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
} else {
mono_marshal_lock_internal ();
if (mono_method_get_wrapper_cache (method)->remoting_invoke_cache)
- wrps = g_hash_table_lookup (mono_method_get_wrapper_cache (method)->remoting_invoke_cache, method);
+ wrps = (MonoRemotingMethods *)g_hash_table_lookup (mono_method_get_wrapper_cache (method)->remoting_invoke_cache, method);
if (wrps) {
switch (wrapper_type) {
cache = get_cache_full (&mono_method_get_wrapper_cache (key)->remoting_invoke_cache, mono_aligned_addr_hash, NULL, NULL, g_free);
mono_marshal_lock_internal ();
- wrps = g_hash_table_lookup (cache, key);
+ wrps = (MonoRemotingMethods *)g_hash_table_lookup (cache, key);
if (!wrps) {
wrps = g_new0 (MonoRemotingMethods, 1);
g_hash_table_insert (cache, key, wrps);
} else {
/* runtime_invoke expects a boxed instance */
if (mono_class_is_nullable (mono_class_from_mono_type (sig->params [i])))
- mparams[i] = mono_nullable_box (params [i], klass);
+ mparams[i] = mono_nullable_box ((guint8 *)params [i], klass);
else
mparams[i] = params [i];
}
if (mt == MONO_MARSHAL_COPY) {
int i, len = mono_array_length ((MonoArray *)dst);
for (i = 0; i < len; i++) {
- MonoObject *item = mono_array_get ((MonoArray *)src, gpointer, i);
+ MonoObject *item = (MonoObject *)mono_array_get ((MonoArray *)src, gpointer, i);
mono_array_setref ((MonoArray *)dst, i, mono_marshal_xdomain_copy_value (item));
}
} else {
mono_domain_assemblies_lock (domain);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- ass = tmp->data;
+ ass = (MonoAssembly *)tmp->data;
if (ass->image == image)
break;
}
/* try */
- main_clause = mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
+ main_clause = (MonoExceptionClause *)mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
main_clause->try_offset = mono_mb_get_label (mb);
/* Clean the call context */
/* Count the number of parameters that need to be serialized */
- marshal_types = alloca (sizeof (int) * sig->param_count);
+ marshal_types = (int *)alloca (sizeof (int) * sig->param_count);
complex_count = complex_out_count = 0;
for (i = 0; i < sig->param_count; i++) {
MonoType *ptype = sig->params[i];
if (mt == MONO_MARSHAL_COPY) {
int i, len = mono_array_length (acopy);
for (i = 0; i < len; i++) {
- MonoObject *item = mono_array_get (acopy, gpointer, i);
+ MonoObject *item = (MonoObject *)mono_array_get (acopy, gpointer, i);
mono_array_setref (acopy, i, mono_marshal_xdomain_copy_value (item));
}
}
static gboolean
get_caller_no_reflection_related (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
- MonoMethod **dest = data;
+ MonoMethod **dest = (MonoMethod **)data;
const char *ns;
/* skip unmanaged frames */
static gboolean
get_caller_of_elevated_trust_code (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
- ElevatedTrustCookie *cookie = data;
+ ElevatedTrustCookie *cookie = (ElevatedTrustCookie *)data;
/* skip unmanaged frames and wrappers */
if (!managed || (m->wrapper_type != MONO_WRAPPER_NONE))
if (cinfo && mono_custom_attrs_has_attr (cinfo, security_critical_attribute ()))
level = MONO_SECURITY_CORE_CLR_CRITICAL;
- return level;
+ return (MonoSecurityCoreCLRLevel)level;
}
/*
{
data->entry_count = 0;
data->entry_capacity = entry_capacity;
- data->entries = g_malloc (sizeof (SeqPointDataEntry) * entry_capacity);
+ data->entries = (SeqPointDataEntry *)g_malloc (sizeof (SeqPointDataEntry) * entry_capacity);
}
void
fsize = ftell(f);
fseek(f, 0, SEEK_SET);
- buffer_orig = buffer = g_malloc(fsize + 1);
+ buffer_orig = buffer = (guint8 *)g_malloc (fsize + 1);
fread(buffer_orig, fsize, 1, f);
fclose(f);
// Add size of entry_count and native_base_offsets
size += 4 + data->entry_count * 4;
- buffer_orig = buffer = g_malloc (size);
+ buffer_orig = buffer = (guint8 *)g_malloc (size);
encode_var_int (buffer, &buffer, data->entry_count);
} SeqPoint;
typedef struct MonoSeqPointInfo {
- int dummy[0];
+ int dummy [1];
} MonoSeqPointInfo;
typedef struct {
static gboolean
is_bridge_object_dead (GCObject *obj, void *data)
{
- SgenHashTable *table = data;
- unsigned char *value = sgen_hash_table_lookup (table, obj);
+ SgenHashTable *table = (SgenHashTable *)data;
+ unsigned char *value = (unsigned char *)sgen_hash_table_lookup (table, obj);
if (!value)
return FALSE;
return !*value;
static int
compare_xrefs (const void *a_ptr, const void *b_ptr)
{
- const MonoGCBridgeXRef *a = a_ptr;
- const MonoGCBridgeXRef *b = b_ptr;
+ const MonoGCBridgeXRef *a = (const MonoGCBridgeXRef *)a_ptr;
+ const MonoGCBridgeXRef *b = (const MonoGCBridgeXRef *)b_ptr;
if (a->src_scc_index < b->src_scc_index)
return -1;
gboolean new_entry;
g_assert (scc->num_objs > 0);
- a_scc_index_ptr = sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [0]);
+ a_scc_index_ptr = (int *)sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [0]);
g_assert (a_scc_index_ptr);
a_scc_index = *a_scc_index_ptr;
g_assert (a_scc->num_objs == scc->num_objs);
for (j = 1; j < scc->num_objs; ++j) {
- a_scc_index_ptr = sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [j]);
+ a_scc_index_ptr = (int *)sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [j]);
g_assert (a_scc_index_ptr);
g_assert (*a_scc_index_ptr == a_scc_index);
}
*/
xrefs_alloc_size = a->num_xrefs * sizeof (MonoGCBridgeXRef);
- a_xrefs = sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
- b_xrefs = sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
+ a_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
+ b_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
memcpy (a_xrefs, a->api_xrefs, xrefs_alloc_size);
for (i = 0; i < b->num_xrefs; ++i) {
g_assert (xref->src_scc_index != xref->dst_scc_index);
- scc_index_ptr = sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->src_scc_index));
+ scc_index_ptr = (int *)sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->src_scc_index));
g_assert (scc_index_ptr);
b_xrefs [i].src_scc_index = *scc_index_ptr;
- scc_index_ptr = sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->dst_scc_index));
+ scc_index_ptr = (int *)sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->dst_scc_index));
g_assert (scc_index_ptr);
b_xrefs [i].dst_scc_index = *scc_index_ptr;
}
}
static void G_GNUC_UNUSED
-sgen_client_binary_protocol_block_set_state (gpointer addr, size_t size, int old, int new)
+sgen_client_binary_protocol_block_set_state (gpointer addr, size_t size, int old, int new_)
{
}
o = (MonoArray*)start;
o->obj.vtable = (MonoVTable*)get_array_fill_vtable ();
/* Mark this as not a real object */
- o->obj.synchronisation = GINT_TO_POINTER (-1);
+ o->obj.synchronisation = (MonoThreadsSync *)GINT_TO_POINTER (-1);
o->bounds = NULL;
o->max_length = (mono_array_size_t)(size - MONO_SIZEOF_MONO_ARRAY);
static gboolean
object_in_domain_predicate (MonoObject *obj, void *user_data)
{
- MonoDomain *domain = user_data;
+ MonoDomain *domain = (MonoDomain *)user_data;
if (mono_object_domain (obj) == domain) {
SGEN_LOG (5, "Unregistering finalizer for object: %p (%s)", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj)));
return TRUE;
LOCK_GC;
- node = sgen_alloc_internal (INTERNAL_MEM_EPHEMERON_LINK);
+ node = (EphemeronLinkNode *)sgen_alloc_internal (INTERNAL_MEM_EPHEMERON_LINK);
if (!node) {
UNLOCK_GC;
return FALSE;
void *res = calloc (1, size);
if (!res)
return NULL;
- if (!mono_gc_register_root (res, size, descr, source, msg)) {
+ if (!mono_gc_register_root ((char *)res, size, descr, source, msg)) {
free (res);
res = NULL;
}
void
mono_gc_free_fixed (void* addr)
{
- mono_gc_deregister_root (addr);
+ mono_gc_deregister_root ((char *)addr);
free (addr);
}
mono_mb_patch_short_branch (mb, pos);
- clause = mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
+ clause = (MonoExceptionClause *)mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
clause->try_offset = mono_mb_get_label (mb);
/* vtable->klass->sizes.element_size */
MonoArray *arr = (MonoArray*)obj;
guint8 *card_data, *card_base;
guint8 *card_data_end;
- char *obj_start = sgen_card_table_align_pointer (obj);
+ char *obj_start = (char *)sgen_card_table_align_pointer (obj);
mword bounds_size;
mword obj_size = sgen_mono_array_size (vt, arr, &bounds_size, sgen_vtable_get_descriptor (vt));
/* We don't want to scan the bounds entries at the end of multidimensional arrays */
HEAVY_STAT (++los_array_cards);
for (; elem < card_end; elem += SIZEOF_VOID_P) {
- gpointer new, old = *(gpointer*)elem;
+ GCObject *new_;
+ gpointer old = *(gpointer*)elem;
if ((mod_union && old) || G_UNLIKELY (sgen_ptr_in_nursery (old))) {
HEAVY_STAT (++los_array_remsets);
copy_func ((GCObject**)elem, ctx.queue);
- new = *(gpointer*)elem;
- if (G_UNLIKELY (sgen_ptr_in_nursery (new)))
- sgen_add_to_global_remset (elem, new);
+ new_ = *(GCObject **)elem;
+ if (G_UNLIKELY (sgen_ptr_in_nursery (new_)))
+ sgen_add_to_global_remset (elem, new_);
}
}
}
}
return;
case ROOT_DESC_COMPLEX: {
- gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
+ gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
gsize bwords = (*bitmap_data) - 1;
void **start_run = start_root;
bitmap_data++;
void **start_root;
RootRecord *root;
report.count = 0;
- SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
precisely_report_roots_from (&report, start_root, (void**)root->end_root, root->root_desc);
} SGEN_HASH_TABLE_FOREACH_END;
static void
walk_references (GCObject *start, size_t size, void *data)
{
- HeapWalkInfo *hwi = data;
+ HeapWalkInfo *hwi = (HeapWalkInfo *)data;
hwi->called = 0;
hwi->count = 0;
collect_references (hwi, start, size);
void
mono_gc_conservatively_scan_area (void *start, void *end)
{
- sgen_conservatively_pin_objects_from (start, end, scan_area_arg_start, scan_area_arg_end, PIN_TYPE_STACK);
+ sgen_conservatively_pin_objects_from ((void **)start, (void **)end, scan_area_arg_start, scan_area_arg_end, PIN_TYPE_STACK);
}
void*
mono_gc_scan_object (void *obj, void *gc_data)
{
- ScanCopyContext *ctx = gc_data;
+ ScanCopyContext *ctx = (ScanCopyContext *)gc_data;
ctx->ops->copy_or_mark_object ((GCObject**)&obj, ctx->queue);
return obj;
}
g_assert (info->client_info.suspend_done);
SGEN_LOG (3, "Scanning thread %p, range: %p-%p, size: %zd, pinned=%zd", info, info->client_info.stack_start, info->client_info.stack_end, (char*)info->client_info.stack_end - (char*)info->client_info.stack_start, sgen_get_pinned_count ());
if (mono_gc_get_gc_callbacks ()->thread_mark_func && !conservative_stack_mark) {
- mono_gc_get_gc_callbacks ()->thread_mark_func (info->client_info.runtime_data, aligned_stack_start, info->client_info.stack_end, precise, &ctx);
+ mono_gc_get_gc_callbacks ()->thread_mark_func (info->client_info.runtime_data, (guint8 *)aligned_stack_start, (guint8 *)info->client_info.stack_end, precise, &ctx);
} else if (!precise) {
if (!conservative_stack_mark) {
fprintf (stderr, "Precise stack mark not supported - disabling.\n");
conservative_stack_mark = TRUE;
}
- sgen_conservatively_pin_objects_from (aligned_stack_start, info->client_info.stack_end, start_nursery, end_nursery, PIN_TYPE_STACK);
+ sgen_conservatively_pin_objects_from ((void **)aligned_stack_start, (void **)info->client_info.stack_end, start_nursery, end_nursery, PIN_TYPE_STACK);
}
if (!precise) {
// We force a spill of all registers into the stack and pass a chunk of data into sgen.
MonoThreadUnwindState *state = &info->client_info.info.thread_saved_state [SELF_SUSPEND_STATE_INDEX];
if (state && state->gc_stackdata) {
- sgen_conservatively_pin_objects_from (state->gc_stackdata, (void**)((char*)state->gc_stackdata + state->gc_stackdata_size),
+ sgen_conservatively_pin_objects_from ((void **)state->gc_stackdata, (void**)((char*)state->gc_stackdata + state->gc_stackdata_size),
start_nursery, end_nursery, PIN_TYPE_STACK);
}
}
gboolean
mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain)
{
- MonoDomain *gchandle_domain = sgen_gchandle_get_metadata (gchandle);
+ MonoDomain *gchandle_domain = (MonoDomain *)sgen_gchandle_get_metadata (gchandle);
return domain->domain_id == gchandle_domain->domain_id;
}
static gpointer
null_link_if_in_domain (gpointer hidden, GCHandleType handle_type, int max_generation, gpointer user)
{
- MonoDomain *unloading_domain = user;
+ MonoDomain *unloading_domain = (MonoDomain *)user;
MonoDomain *obj_domain;
gboolean is_weak = MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type);
if (MONO_GC_HANDLE_IS_OBJECT_POINTER (hidden)) {
- MonoObject *obj = MONO_GC_REVEAL_POINTER (hidden, is_weak);
+ MonoObject *obj = (MonoObject *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
obj_domain = mono_object_domain (obj);
} else {
- obj_domain = MONO_GC_REVEAL_POINTER (hidden, is_weak);
+ obj_domain = (MonoDomain *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
}
if (unloading_domain->domain_id == obj_domain->domain_id)
return NULL;
{
guint type;
for (type = HANDLE_TYPE_MIN; type < HANDLE_TYPE_MAX; ++type)
- sgen_gchandle_iterate (type, GENERATION_OLD, null_link_if_in_domain, domain);
+ sgen_gchandle_iterate ((GCHandleType)type, GENERATION_OLD, null_link_if_in_domain, domain);
}
void
cb.thread_detach = sgen_thread_detach;
cb.thread_unregister = sgen_thread_unregister;
cb.thread_attach = sgen_thread_attach;
- cb.mono_method_is_critical = (gpointer)is_critical_method;
+ cb.mono_method_is_critical = (gboolean (*)(void *))is_critical_method;
cb.mono_thread_in_critical_region = thread_in_critical_region;
mono_threads_init (&cb, sizeof (SgenThreadInfo));
while (capacity > da->capacity)
da->capacity *= 2;
- new_data = sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ new_data = (char *)sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
memcpy (new_data, da->data, elem_size * da->size);
if (old_capacity > 0)
sgen_free_internal_dynamic (da->data, elem_size * old_capacity, INTERNAL_MEM_BRIDGE_DATA);
static void
dyn_array_int_add (DynIntArray *da, int x)
{
- int *p = dyn_array_add (&da->array, sizeof (int));
+ int *p = (int *)dyn_array_add (&da->array, sizeof (int));
*p = x;
}
void *ptr0 = da->array.data;
void **p0;
dyn_array_init (&da->array);
- p0 = dyn_array_add (&da->array, sizeof (void*));
+ p0 = (void **)dyn_array_add (&da->array, sizeof (void*));
*p0 = ptr0;
- p = dyn_array_add (&da->array, sizeof (void*));
+ p = (void **)dyn_array_add (&da->array, sizeof (void*));
} else
#endif
{
- p = dyn_array_add (&da->array, sizeof (void*));
+ p = (void **)dyn_array_add (&da->array, sizeof (void*));
}
*p = ptr;
}
static SCC*
dyn_array_scc_add (DynSCCArray *da)
{
- return dyn_array_add (&da->array, sizeof (SCC));
+ return (SCC *)dyn_array_add (&da->array, sizeof (SCC));
}
static SCC*
static HashEntry*
get_hash_entry (MonoObject *obj, gboolean *existing)
{
- HashEntry *entry = sgen_hash_table_lookup (&hash_table, obj);
+ HashEntry *entry = (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
HashEntry new_entry;
if (entry) {
sgen_hash_table_replace (&hash_table, obj, &new_entry, NULL);
- return sgen_hash_table_lookup (&hash_table, obj);
+ return (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
}
static void
int total_srcs = 0;
int max_srcs = 0;
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
int entry_size = dyn_array_ptr_size (&entry->srcs);
total_srcs += entry_size;
if (entry_size > max_srcs)
char *start;
++dfs1_passes;
- obj_entry = dyn_array_ptr_pop (&dfs_stack);
+ obj_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
if (obj_entry) {
/* obj_entry needs to be expanded */
- src = dyn_array_ptr_pop (&dfs_stack);
+ src = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
if (src)
g_assert (!src->v.dfs1.forwarded_to);
*/
#ifdef OPTIMIZATION_FORWARD
if (!obj_entry->is_bridge && num_links == 1) {
- HashEntry *dst_entry = dyn_array_ptr_pop (&dfs_stack);
- HashEntry *obj_entry_again = dyn_array_ptr_pop (&dfs_stack);
+ HashEntry *dst_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
+ HashEntry *obj_entry_again = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
g_assert (obj_entry_again == obj_entry);
g_assert (!dst_entry->v.dfs1.forwarded_to);
if (obj_entry != dst_entry) {
} else {
/* obj_entry needs to be finished */
- obj_entry = dyn_array_ptr_pop (&dfs_stack);
+ obj_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
//g_print ("finish %s\n", sgen_safe_name (obj_entry->obj));
register_finishing_time (obj_entry, ++current_time);
dyn_array_ptr_push (&dfs_stack, entry);
do {
- entry = dyn_array_ptr_pop (&dfs_stack);
+ entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
++dfs2_passes;
if (entry->v.dfs2.scc_index >= 0) {
MonoObject *obj;
HashEntry *entry;
size_t prefix_len = strlen (dump_prefix);
- char *filename = alloca(prefix_len + 64);
+ char *filename = (char *)alloca (prefix_len + 64);
FILE *file;
int edge_id = 0;
"</attributes>\n");
fprintf (file, "<nodes>\n");
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
MonoVTable *vt = SGEN_LOAD_VTABLE (obj);
fprintf (file, "<node id=\"%p\"><attvalues><attvalue for=\"0\" value=\"%s.%s\"/><attvalue for=\"1\" value=\"%s\"/></attvalues></node>\n",
obj, vt->klass->name_space, vt->klass->name, entry->is_bridge ? "true" : "false");
fprintf (file, "</nodes>\n");
fprintf (file, "<edges>\n");
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
int i;
for (i = 0; i < dyn_array_ptr_size (&entry->srcs); ++i) {
- HashEntry *src = dyn_array_ptr_get (&entry->srcs, i);
+ HashEntry *src = (HashEntry *)dyn_array_ptr_get (&entry->srcs, i);
fprintf (file, "<edge id=\"%d\" source=\"%p\" target=\"%p\"/>\n", edge_id++, sgen_hash_table_key_for_value_pointer (src), obj);
}
} SGEN_HASH_TABLE_FOREACH_END;
*/
bridge_count = dyn_array_ptr_size (®istered_bridges);
for (i = 0; i < bridge_count ; ++i)
- register_bridge_object (dyn_array_ptr_get (®istered_bridges, i));
+ register_bridge_object ((MonoObject *)dyn_array_ptr_get (®istered_bridges, i));
for (i = 0; i < bridge_count; ++i)
- dfs1 (get_hash_entry (dyn_array_ptr_get (®istered_bridges, i), NULL));
+ dfs1 (get_hash_entry ((MonoObject *)dyn_array_ptr_get (®istered_bridges, i), NULL));
/* Remove all forwarded objects. */
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
if (entry->v.dfs1.forwarded_to) {
g_assert (dyn_array_ptr_size (&entry->srcs) == 0);
SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE);
/* alloc and fill array of all entries */
- all_entries = sgen_alloc_internal_dynamic (sizeof (HashEntry*) * hash_table.num_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ all_entries = (HashEntry **)sgen_alloc_internal_dynamic (sizeof (HashEntry*) * hash_table.num_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
j = 0;
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
g_assert (entry->v.dfs1.finishing_time > 0);
all_entries [j++] = entry;
fist_pass_links += dyn_array_ptr_size (&entry->srcs);
/* sort array according to decreasing finishing time */
qsort_hash_entries (all_entries, hash_table.num_entries);
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
entry->v.dfs2.scc_index = -1;
} SGEN_HASH_TABLE_FOREACH_END;
max_sccs_links = MAX (max_sccs_links, dyn_array_int_size (&scc->XREFS));
}
- api_sccs = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_sccs = (MonoGCBridgeSCC **)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
num_xrefs = 0;
j = 0;
for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
if (!scc->num_bridge_entries)
continue;
- api_sccs [j] = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * scc->num_bridge_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_sccs [j] = (MonoGCBridgeSCC *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * scc->num_bridge_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
api_sccs [j]->is_alive = FALSE;
api_sccs [j]->num_objs = scc->num_bridge_entries;
scc->num_bridge_entries = 0;
num_xrefs += dyn_array_int_size (&scc->XREFS);
}
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, MonoObject *, obj, HashEntry *, entry) {
if (entry->is_bridge) {
SCC *scc = dyn_array_scc_get_ptr (&sccs, entry->v.dfs2.scc_index);
api_sccs [scc->api_index]->objs [scc->num_bridge_entries++] = sgen_hash_table_key_for_value_pointer (entry);
}
} SGEN_HASH_TABLE_FOREACH_END;
- api_xrefs = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
j = 0;
for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
int k;
}
}
- entry = sgen_hash_table_lookup (&hash_table, obj);
+ entry = (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
if (!entry)
return;
while (capacity > da->capacity)
da->capacity *= 2;
- new_data = sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ new_data = (char *)sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
memcpy (new_data, da->data, elem_size * da->size);
sgen_free_internal_dynamic (da->data, elem_size * old_capacity, INTERNAL_MEM_BRIDGE_DATA);
da->data = new_data;
static void
dyn_array_int_add (DynIntArray *da, int x)
{
- int *p = dyn_array_add (&da->array, sizeof (int));
+ int *p = (int *)dyn_array_add (&da->array, sizeof (int));
*p = x;
}
static void
dyn_array_ptr_add (DynPtrArray *da, void *ptr)
{
- void **p = dyn_array_add (&da->array, sizeof (void*));
+ void **p = (void **)dyn_array_add (&da->array, sizeof (void*));
*p = ptr;
}
static SCC*
dyn_array_scc_add (DynSCCArray *da)
{
- return dyn_array_add (&da->array, sizeof (SCC));
+ return (SCC *)dyn_array_add (&da->array, sizeof (SCC));
}
static SCC*
static HashEntry*
get_hash_entry (GCObject *obj, gboolean *existing)
{
- HashEntry *entry = sgen_hash_table_lookup (&hash_table, obj);
+ HashEntry *entry = (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
HashEntry new_entry;
if (entry) {
sgen_hash_table_replace (&hash_table, obj, &new_entry, NULL);
- return sgen_hash_table_lookup (&hash_table, obj);
+ return (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
}
static void
int total_srcs = 0;
int max_srcs = 0;
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, GCObject *, obj, HashEntry *, entry) {
int entry_size = dyn_array_ptr_size (&entry->srcs);
total_srcs += entry_size;
if (entry_size > max_srcs)
GCObject *obj;
++dfs1_passes;
- obj_entry = dyn_array_ptr_pop (&dfs_stack);
+ obj_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
if (obj_entry) {
char *start;
mword desc;
- src = dyn_array_ptr_pop (&dfs_stack);
+ src = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
obj = obj_entry->obj;
desc = sgen_obj_get_descriptor_safe (obj);
start = (char*)obj;
#include "sgen/sgen-scan-object.h"
} else {
- obj_entry = dyn_array_ptr_pop (&dfs_stack);
+ obj_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
//g_print ("finish %s\n", sgen_safe_name (obj_entry->obj));
register_finishing_time (obj_entry, current_time++);
dyn_array_ptr_push (&dfs_stack, entry);
do {
- entry = dyn_array_ptr_pop (&dfs_stack);
+ entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
++dfs2_passes;
if (entry->scc_index >= 0) {
*/
bridge_count = dyn_array_ptr_size (®istered_bridges);
for (i = 0; i < bridge_count ; ++i)
- register_bridge_object (dyn_array_ptr_get (®istered_bridges, i));
+ register_bridge_object ((GCObject *)dyn_array_ptr_get (®istered_bridges, i));
for (i = 0; i < bridge_count; ++i)
- dfs1 (get_hash_entry (dyn_array_ptr_get (®istered_bridges, i), NULL));
+ dfs1 (get_hash_entry ((GCObject *)dyn_array_ptr_get (®istered_bridges, i), NULL));
SGEN_TV_GETTIME (atv);
step_2 = SGEN_TV_ELAPSED (btv, atv);
/* alloc and fill array of all entries */
- all_entries = sgen_alloc_internal_dynamic (sizeof (HashEntry*) * hash_table.num_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ all_entries = (HashEntry **)sgen_alloc_internal_dynamic (sizeof (HashEntry*) * hash_table.num_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
j = 0;
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, GCObject *, obj, HashEntry *, entry) {
g_assert (entry->finishing_time >= 0);
all_entries [j++] = entry;
fist_pass_links += dyn_array_ptr_size (&entry->srcs);
max_sccs_links = MAX (max_sccs_links, dyn_array_int_size (&scc->xrefs));
}
- api_sccs = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_sccs = (MonoGCBridgeSCC **)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
num_xrefs = 0;
j = 0;
for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
if (!scc->num_bridge_entries)
continue;
- api_sccs [j] = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * scc->num_bridge_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_sccs [j] = (MonoGCBridgeSCC *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * scc->num_bridge_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
api_sccs [j]->is_alive = FALSE;
api_sccs [j]->num_objs = scc->num_bridge_entries;
scc->num_bridge_entries = 0;
num_xrefs += dyn_array_int_size (&scc->xrefs);
}
- SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) {
+ SGEN_HASH_TABLE_FOREACH (&hash_table, GCObject *, obj, HashEntry *, entry) {
if (entry->is_bridge) {
SCC *scc = dyn_array_scc_get_ptr (&sccs, entry->scc_index);
api_sccs [scc->api_index]->objs [scc->num_bridge_entries++] = (MonoObject*)entry->obj;
}
} SGEN_HASH_TABLE_FOREACH_END;
- api_xrefs = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
j = 0;
for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
int k;
}
}
- entry = sgen_hash_table_lookup (&hash_table, obj);
+ entry = (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
if (!entry)
return;
g_error ("failed sigaction");
}
- sinfo.sa_handler = (void*) restart_handler;
+ sinfo.sa_handler = (void (*)(int))restart_handler;
if (sigaction (restart_signal_num, &sinfo, NULL) != 0) {
g_error ("failed sigaction");
}
* missing methods (#13951). To work around this, we disable the AOT fallback. For this to work, the JIT needs
* to register the jit info for all GC critical methods after they are JITted/loaded.
*/
- ji = mono_jit_info_table_find_internal (domain, ip, FALSE, FALSE);
+ ji = mono_jit_info_table_find_internal (domain, (char *)ip, FALSE, FALSE);
if (!ji)
return FALSE;
char *stack_start;
/* Once we remove the old suspend code, we should move sgen to directly access the state in MonoThread */
- info->client_info.stopped_domain = mono_thread_info_tls_get (info, TLS_KEY_DOMAIN);
+ info->client_info.stopped_domain = (MonoDomain *)mono_thread_info_tls_get (info, TLS_KEY_DOMAIN);
info->client_info.stopped_ip = (gpointer) MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx);
stack_start = (char*)MONO_CONTEXT_GET_SP (&mono_thread_info_get_suspend_state (info)->ctx) - REDZONE_SIZE;
while (capacity > da->capacity)
da->capacity *= 2;
- new_data = sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ new_data = (char *)sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
if (da->data) {
memcpy (new_data, da->data, elem_size * da->size);
sgen_free_internal_dynamic (da->data, elem_size * old_capacity, INTERNAL_MEM_BRIDGE_DATA);
static void
dyn_array_ptr_add (DynPtrArray *da, void *ptr)
{
- void **p = dyn_array_add (&da->array, sizeof (void*));
+ void **p = (void **)dyn_array_add (&da->array, sizeof (void*));
*p = ptr;
}
static ObjectBucket*
new_object_bucket (void)
{
- ObjectBucket *res = sgen_alloc_internal (INTERNAL_MEM_TARJAN_OBJ_BUCKET);
+ ObjectBucket *res = (ObjectBucket *)sgen_alloc_internal (INTERNAL_MEM_TARJAN_OBJ_BUCKET);
res->next_data = &res->data [0];
return res;
}
static ColorBucket*
new_color_bucket (void)
{
- ColorBucket *res = sgen_alloc_internal (INTERNAL_MEM_TARJAN_OBJ_BUCKET);
+ ColorBucket *res = (ColorBucket *)sgen_alloc_internal (INTERNAL_MEM_TARJAN_OBJ_BUCKET);
res->next_data = &res->data [0];
return res;
}
if (size == 0)
color = NULL;
else if (size == 1) {
- color = dyn_array_ptr_get (&color_merge_array, 0);
+ color = (ColorData *)dyn_array_ptr_get (&color_merge_array, 0);
} else
color = new_color (FALSE);
ColorData *color_data = NULL;
for (i = dyn_array_ptr_size (&loop_stack) - 1; i >= 0; --i) {
- ScanData *other = dyn_array_ptr_get (&loop_stack, i);
+ ScanData *other = (ScanData *)dyn_array_ptr_get (&loop_stack, i);
found_bridge |= other->is_bridge;
if (found_bridge || other == data)
break;
}
while (dyn_array_ptr_size (&loop_stack) > 0) {
- ScanData *other = dyn_array_ptr_pop (&loop_stack);
+ ScanData *other = (ScanData *)dyn_array_ptr_pop (&loop_stack);
#if DUMP_GRAPH
printf ("\tmember %s (%p) index %d low-index %d color %p state %d\n", safe_name_bridge (other->obj), other->obj, other->index, other->low_index, other->color, other->state);
g_assert (found);
for (i = 0; i < dyn_array_ptr_size (&color_merge_array); ++i) {
- ColorData *cd = dyn_array_ptr_get (&color_merge_array, i);
+ ColorData *cd = (ColorData *)dyn_array_ptr_get (&color_merge_array, i);
g_assert (cd->visited);
cd->visited = FALSE;
}
dyn_array_ptr_set_size (&color_merge_array, 0);
while (dyn_array_ptr_size (&scan_stack) > 0) {
- ScanData *data = dyn_array_ptr_pop (&scan_stack);
+ ScanData *data = (ScanData *)dyn_array_ptr_pop (&scan_stack);
/**
* Ignore finished objects on stack, they happen due to loops. For example:
bridge_count = dyn_array_ptr_size (®istered_bridges);
for (i = 0; i < bridge_count ; ++i)
- register_bridge_object (dyn_array_ptr_get (®istered_bridges, i));
+ register_bridge_object ((GCObject *)dyn_array_ptr_get (®istered_bridges, i));
setup_time = step_timer (&curtime);
for (i = 0; i < bridge_count; ++i) {
- ScanData *sd = find_data (dyn_array_ptr_get (®istered_bridges, i));
+ ScanData *sd = find_data ((GCObject *)dyn_array_ptr_get (®istered_bridges, i));
if (sd->state == INITIAL) {
dyn_array_ptr_push (&scan_stack, sd);
dfs ();
{
int i;
for (i = 0; i < dyn_array_ptr_size (&color->other_colors); ++i) {
- ColorData *src = dyn_array_ptr_get (&color->other_colors, i);
+ ColorData *src = (ColorData *)dyn_array_ptr_get (&color->other_colors, i);
if (src->visited)
continue;
src->visited = TRUE;
{
int i;
for (i = 0; i < dyn_array_ptr_size (&color->other_colors); ++i) {
- ColorData *src = dyn_array_ptr_get (&color->other_colors, i);
+ ColorData *src = (ColorData *)dyn_array_ptr_get (&color->other_colors, i);
if (!src->visited)
continue;
src->visited = FALSE;
#endif
/* This is a straightforward translation from colors to the bridge callback format. */
- api_sccs = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_colors_with_bridges, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_sccs = (MonoGCBridgeSCC **)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_colors_with_bridges, INTERNAL_MEM_BRIDGE_DATA, TRUE);
api_index = xref_count = 0;
for (cur = root_color_bucket; cur; cur = cur->next) {
if (!bridges)
continue;
- api_sccs [api_index] = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * bridges, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_sccs [api_index] = (MonoGCBridgeSCC *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * bridges, INTERNAL_MEM_BRIDGE_DATA, TRUE);
api_sccs [api_index]->is_alive = FALSE;
api_sccs [api_index]->num_objs = bridges;
cd->api_index = api_index;
for (j = 0; j < bridges; ++j)
- api_sccs [api_index]->objs [j] = dyn_array_ptr_get (&cd->bridges, j);
+ api_sccs [api_index]->objs [j] = (MonoObject *)dyn_array_ptr_get (&cd->bridges, j);
api_index++;
}
}
dump_color_table (" after xref pass", TRUE);
#endif
- api_xrefs = sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * xref_count, INTERNAL_MEM_BRIDGE_DATA, TRUE);
+ api_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * xref_count, INTERNAL_MEM_BRIDGE_DATA, TRUE);
api_index = 0;
for (cur = root_color_bucket; cur; cur = cur->next) {
ColorData *src;
continue;
for (j = 0; j < dyn_array_ptr_size (&src->other_colors); ++j) {
- ColorData *dest = dyn_array_ptr_get (&src->other_colors, j);
+ ColorData *dest = (ColorData *)dyn_array_ptr_get (&src->other_colors, j);
g_assert (dyn_array_ptr_size (&dest->bridges)); /* We flattened the color graph, so this must never happen. */
api_xrefs [api_index].src_scc_index = src->api_index;
{
if (!toggleref_array) {
toggleref_array_capacity = 32;
- toggleref_array = sgen_alloc_internal_dynamic (
+ toggleref_array = (MonoGCToggleRef *)sgen_alloc_internal_dynamic (
toggleref_array_capacity * sizeof (MonoGCToggleRef),
INTERNAL_MEM_TOGGLEREF_DATA,
TRUE);
while (toggleref_array_capacity < toggleref_array_size + capacity)
toggleref_array_capacity *= 2;
- tmp = sgen_alloc_internal_dynamic (
+ tmp = (MonoGCToggleRef *)sgen_alloc_internal_dynamic (
toggleref_array_capacity * sizeof (MonoGCToggleRef),
INTERNAL_MEM_TOGGLEREF_DATA,
TRUE);
test_toggleref_callback (MonoObject *obj)
{
static MonoClassField *mono_toggleref_test_field;
- int status = MONO_TOGGLE_REF_DROP;
+ MonoToggleRefStatus status = MONO_TOGGLE_REF_DROP;
if (!mono_toggleref_test_field) {
mono_toggleref_test_field = mono_class_get_field_from_name (mono_object_get_class (obj), "__test");
*error = 0;
- sock_family=convert_family(family);
+ sock_family = convert_family ((MonoAddressFamily)family);
if(sock_family==-1) {
*error = WSAEAFNOSUPPORT;
return(NULL);
}
- sock_proto=convert_proto(proto);
+ sock_proto = convert_proto ((MonoProtocolType)proto);
if(sock_proto==-1) {
*error = WSAEPROTONOSUPPORT;
return(NULL);
}
- sock_type=convert_type(type);
+ sock_type = convert_type ((MonoSocketType)type);
if(sock_type==-1) {
*error = WSAESOCKTNOSUPPORT;
return(NULL);
*error = 0;
- salen = get_sockaddr_size (convert_family (af));
+ salen = get_sockaddr_size (convert_family ((MonoAddressFamily)af));
if (salen == 0) {
*error = WSAEAFNOSUPPORT;
return NULL;
}
- sa = (salen <= 128) ? alloca (salen) : g_malloc0 (salen);
+ sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
MONO_PREPARE_BLOCKING;
*error = 0;
- salen = get_sockaddr_size (convert_family (af));
+ salen = get_sockaddr_size (convert_family ((MonoAddressFamily)af));
if (salen == 0) {
*error = WSAEAFNOSUPPORT;
return NULL;
}
- sa = (salen <= 128) ? alloca (salen) : g_malloc0 (salen);
+ sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
/* Note: linux returns just 2 for AF_UNIX. Always. */
MONO_PREPARE_BLOCKING;
mono_raise_exception (mono_exception_from_name(mono_get_corlib (), "System", "SystemException"));
}
- family = convert_family (mono_array_get (data, guint8, 0) + (mono_array_get (data, guint8, 1) << 8));
+ family = convert_family ((MonoAddressFamily)(mono_array_get (data, guint8, 0) + (mono_array_get (data, guint8, 1) << 8)));
if (family == AF_INET) {
struct sockaddr_in *sa;
guint16 port;
}
if (ret == -1 && errno == EINTR) {
- if (mono_thread_test_state (thread, ThreadState_AbortRequested | ThreadState_StopRequested)) {
+ if (mono_thread_test_state (thread, (MonoThreadState)(ThreadState_AbortRequested | ThreadState_StopRequested))) {
g_free (pfds);
return FALSE;
}
* pointers to functions in managed objects that still works
* on 64bit platforms.
*/
- ret = WSAIoctl (sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (void *)&disco_guid, sizeof(GUID),
- (void *)&_wapi_disconnectex, sizeof(void *), &output_bytes, NULL, NULL);
+ ret = WSAIoctl (sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (gchar *)&disco_guid, sizeof(GUID),
+ (gchar *)&_wapi_disconnectex, sizeof(void *), &output_bytes, NULL, NULL);
MONO_FINISH_BLOCKING;
* For an explanation of why this is done, you can read
* the article at http://www.codeproject.com/internet/jbsocketserver3.asp
*/
- ret = WSAIoctl (sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (void *)&trans_guid, sizeof(GUID),
- (void *)&_wapi_transmitfile, sizeof(void *), &output_bytes, NULL, NULL);
+ ret = WSAIoctl (sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (gchar *)&trans_guid, sizeof(GUID),
+ (gchar *)&_wapi_transmitfile, sizeof(void *), &output_bytes, NULL, NULL);
MONO_FINISH_BLOCKING;
MONO_PREPARE_BLOCKING;
if (_wapi_disconnectex != NULL) {
- if (!_wapi_disconnectex (sock, NULL, TF_REUSE_SOCKET, 0))
+ if (!_wapi_disconnectex (sock, NULL, TF_REUSE_SOCKET, (WapiTransmitFileFlags)0))
*error = WSAGetLastError ();
} else if (_wapi_transmitfile != NULL) {
- if (!_wapi_transmitfile (sock, NULL, 0, 0, NULL, NULL, TF_DISCONNECT | TF_REUSE_SOCKET))
+ if (!_wapi_transmitfile (sock, NULL, 0, 0, NULL, NULL, (WapiTransmitFileFlags)(TF_DISCONNECT | TF_REUSE_SOCKET)))
*error = WSAGetLastError ();
} else {
*error = ERROR_NOT_SUPPORTED;
}
if (ret == -1 && errno == EINTR) {
- if (mono_thread_test_state (thread, ThreadState_AbortRequested | ThreadState_StopRequested)) {
+ if (mono_thread_test_state (thread, (MonoThreadState)(ThreadState_AbortRequested | ThreadState_StopRequested))) {
g_free (pfds);
*sockets = NULL;
return;
#endif
{
- ret = convert_sockopt_level_and_name (level, name, &system_level, &system_name);
+ ret = convert_sockopt_level_and_name ((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level, &system_name);
}
if(ret==-1) {
*error = 0;
- ret=convert_sockopt_level_and_name(level, name, &system_level,
+ ret=convert_sockopt_level_and_name((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level,
&system_name);
if(ret==-1) {
*error = WSAENOPROTOOPT;
sol_ipv6 = mono_networking_get_ipv6_protocol ();
sol_ip = mono_networking_get_ip_protocol ();
- ret=convert_sockopt_level_and_name(level, name, &system_level,
+ ret=convert_sockopt_level_and_name((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level,
&system_name);
#if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
* Get group address
*/
field = mono_class_get_field_from_name (obj_val->vtable->klass, "group");
- address = *(gpointer *)(((char *)obj_val) + field->offset);
+ address = *(MonoObject **)(((char *)obj_val) + field->offset);
if(address) {
mreq6.ipv6mr_multiaddr = ipaddress_to_struct_in6_addr (address);
* those :-(
*/
field = mono_class_get_field_from_name (obj_val->vtable->klass, "group");
- address = *(gpointer *)(((char *)obj_val) + field->offset);
+ address = *(MonoObject **)(((char *)obj_val) + field->offset);
/* address might not be defined and if so, set the address to ADDR_ANY.
*/
}
field = mono_class_get_field_from_name (obj_val->vtable->klass, "local");
- address = *(gpointer *)(((char *)obj_val) + field->offset);
+ address = *(MonoObject **)(((char *)obj_val) + field->offset);
#ifdef HAVE_STRUCT_IP_MREQN
if(address) {
poll_fds_capacity *= 2;
g_assert (poll_fds_size <= poll_fds_capacity);
- poll_fds = g_renew (mono_pollfd, poll_fds, poll_fds_capacity);
+ poll_fds = (mono_pollfd *)g_renew (mono_pollfd, poll_fds, poll_fds_capacity);
}
POLL_INIT_FD (&poll_fds [poll_fds_size - 1], fd, poll_event);
filter_jobs_for_domain (gpointer key, gpointer value, gpointer user_data)
{
FilterSockaresForDomainData *data;
- MonoMList *list = value, *element;
+ MonoMList *list = (MonoMList *)value, *element;
MonoDomain *domain;
MonoGHashTable *states;
g_assert (user_data);
- data = user_data;
+ data = (FilterSockaresForDomainData *)user_data;
domain = data->domain;
states = data->states;
gint operations;
g_assert (user_data);
- states = user_data;
+ states = (MonoGHashTable *)user_data;
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_THREADPOOL, "io threadpool: cal fd %3d, events = %2s | %2s | %3s",
fd, (events & EVENT_IN) ? "RD" : "..", (events & EVENT_OUT) ? "WR" : "..", (events & EVENT_ERR) ? "ERR" : "...");
mono_coop_mutex_init (&threadpool_io->updates_lock);
mono_coop_cond_init (&threadpool_io->updates_cond);
- mono_gc_register_root ((void*)&threadpool_io->updates [0], sizeof (threadpool_io->updates), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_THREAD_POOL, "i/o thread pool updates list");
+ mono_gc_register_root ((char *)&threadpool_io->updates [0], sizeof (threadpool_io->updates), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_THREAD_POOL, "i/o thread pool updates list");
threadpool_io->updates_size = 0;
g_assert (domain);
for (i = 0; i < threadpool->domains->len; ++i) {
- tpdomain = g_ptr_array_index (threadpool->domains, i);
+ tpdomain = (ThreadPoolDomain *)g_ptr_array_index (threadpool->domains, i);
if (tpdomain->domain == domain)
return tpdomain;
}
guint i;
for (i = 0; i < threadpool->domains->len; ++i) {
- ThreadPoolDomain *tmp = g_ptr_array_index (threadpool->domains, i);
+ ThreadPoolDomain *tmp = (ThreadPoolDomain *)g_ptr_array_index (threadpool->domains, i);
if (tmp->outstanding_request > 0)
return TRUE;
}
g_assert (current_idx >= 0);
}
for (i = current_idx + 1; i < len + current_idx + 1; ++i) {
- ThreadPoolDomain *tmp = g_ptr_array_index (threadpool->domains, i % len);
+ ThreadPoolDomain *tmp = (ThreadPoolDomain *)g_ptr_array_index (threadpool->domains, i % len);
if (tmp->outstanding_request > 0) {
tpdomain = tmp;
break;
if (interrupted)
goto done;
- if (mono_coop_cond_timedwait (&threadpool->parked_threads_cond, &threadpool->active_threads_lock, rand_next (rand_handle, 5 * 1000, 60 * 1000)) != 0)
+ if (mono_coop_cond_timedwait (&threadpool->parked_threads_cond, &threadpool->active_threads_lock, rand_next ((void **)rand_handle, 5 * 1000, 60 * 1000)) != 0)
timeout = TRUE;
mono_thread_info_uninstall_interrupt (&interrupted);
else if (res && *(MonoBoolean*) mono_object_unbox (res) == FALSE)
retire = TRUE;
- mono_thread_clr_state (thread , ~ThreadState_Background);
+ mono_thread_clr_state (thread, (MonoThreadState)~ThreadState_Background);
if (!mono_thread_test_state (thread , ThreadState_Background))
ves_icall_System_Threading_Thread_SetState (thread, ThreadState_Background);
mono_coop_mutex_lock (&threadpool->active_threads_lock);
for (i = 0; i < threadpool->working_threads->len; ++i) {
- thread = g_ptr_array_index (threadpool->working_threads, i);
+ thread = (MonoInternalThread *)g_ptr_array_index (threadpool->working_threads, i);
if ((thread->state & ThreadState_WaitSleepJoin) == 0) {
all_waitsleepjoin = FALSE;
break;
void
ves_icall_System_Threading_ThreadPool_GetAvailableThreadsNative (gint32 *worker_threads, gint32 *completion_port_threads)
{
+ ThreadPoolCounter counter;
+
if (!worker_threads || !completion_port_threads)
return;
mono_lazy_initialize (&status, initialize);
- *worker_threads = threadpool->limit_worker_max;
+ counter.as_gint64 = COUNTER_READ ();
+
+ *worker_threads = counter._.max_working - counter._.active;
*completion_port_threads = threadpool->limit_io_max;
}
if (completion_port_threads <= 0 || completion_port_threads > threadpool->limit_io_max)
return FALSE;
- threadpool->limit_worker_max = worker_threads;
- threadpool->limit_io_max = completion_port_threads;
+ threadpool->limit_worker_min = worker_threads;
+ threadpool->limit_io_min = completion_port_threads;
return TRUE;
}
mono_domain_unlock (domain);
g_assert (offset);
- return get_thread_static_data (thread, offset);
+ return (MonoThread **)get_thread_static_data (thread, offset);
}
static void
MONO_OBJECT_SETREF (thread, internal_thread, internal);
start_info = g_new0 (StartInfo, 1);
- start_info->func = func;
+ start_info->func = (guint32 (*)(void *))func;
start_info->obj = thread;
start_info->start_arg = arg;
internal->state = ThreadState_Unstarted;
- InterlockedCompareExchangePointer ((gpointer)&this_obj->internal_thread, internal, NULL);
+ InterlockedCompareExchangePointer ((volatile gpointer *)&this_obj->internal_thread, internal, NULL);
}
HANDLE
ves_icall_System_Threading_Interlocked_CompareExchange_T (MonoObject **location, MonoObject *value, MonoObject *comparand)
{
MonoObject *res;
- res = InterlockedCompareExchangePointer ((gpointer *)location, value, comparand);
+ res = (MonoObject *)InterlockedCompareExchangePointer ((volatile gpointer *)location, value, comparand);
mono_gc_wbarrier_generic_nostore (location);
return res;
}
ves_icall_System_Threading_Interlocked_Exchange_T (MonoObject **location, MonoObject *value)
{
MonoObject *res;
- res = InterlockedExchangePointer ((gpointer *)location, value);
+ res = (MonoObject *)InterlockedExchangePointer ((volatile gpointer *)location, value);
mono_gc_wbarrier_generic_nostore (location);
return res;
}
}
void
-ves_icall_System_Threading_Thread_ClrState (MonoInternalThread* this, guint32 state)
+ves_icall_System_Threading_Thread_ClrState (MonoInternalThread* this_obj, guint32 state)
{
- mono_thread_clr_state (this, state);
+ mono_thread_clr_state (this_obj, (MonoThreadState)state);
if (state & ThreadState_Background) {
/* If the thread changes the background mode, the main thread has to
}
void
-ves_icall_System_Threading_Thread_SetState (MonoInternalThread* this, guint32 state)
+ves_icall_System_Threading_Thread_SetState (MonoInternalThread* this_obj, guint32 state)
{
- mono_thread_set_state (this, state);
+ mono_thread_set_state (this_obj, (MonoThreadState)state);
if (state & ThreadState_Background) {
/* If the thread changes the background mode, the main thread has to
}
guint32
-ves_icall_System_Threading_Thread_GetState (MonoInternalThread* this)
+ves_icall_System_Threading_Thread_GetState (MonoInternalThread* this_obj)
{
guint32 state;
- LOCK_THREAD (this);
+ LOCK_THREAD (this_obj);
- state = this->state;
+ state = this_obj->state;
- UNLOCK_THREAD (this);
+ UNLOCK_THREAD (this_obj);
return state;
}
void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this_obj)
{
MonoInternalThread *current;
- gboolean throw;
+ gboolean throw_;
MonoInternalThread *thread = this_obj->internal_thread;
LOCK_THREAD (thread);
current = mono_thread_internal_current ();
thread->thread_interrupt_requested = TRUE;
- throw = current != thread && (thread->state & ThreadState_WaitSleepJoin);
+ throw_ = current != thread && (thread->state & ThreadState_WaitSleepJoin);
UNLOCK_THREAD (thread);
- if (throw) {
+ if (throw_) {
abort_thread_internal (thread, TRUE, FALSE);
}
}
void mono_thread_current_check_pending_interrupt ()
{
MonoInternalThread *thread = mono_thread_internal_current ();
- gboolean throw = FALSE;
+ gboolean throw_ = FALSE;
LOCK_THREAD (thread);
if (thread->thread_interrupt_requested) {
- throw = TRUE;
+ throw_ = TRUE;
thread->thread_interrupt_requested = FALSE;
}
UNLOCK_THREAD (thread);
- if (throw) {
+ if (throw_) {
mono_raise_exception (mono_get_exception_thread_interrupted ());
}
}
gint8
ves_icall_System_Threading_Volatile_Read1 (void *ptr)
{
- return InterlockedRead8 (ptr);
+ return InterlockedRead8 ((volatile gint8 *)ptr);
}
gint16
ves_icall_System_Threading_Volatile_Read2 (void *ptr)
{
- return InterlockedRead16 (ptr);
+ return InterlockedRead16 ((volatile gint16 *)ptr);
}
gint32
ves_icall_System_Threading_Volatile_Read4 (void *ptr)
{
- return InterlockedRead (ptr);
+ return InterlockedRead ((volatile gint32 *)ptr);
}
gint64
return val;
}
#endif
- return InterlockedRead64 (ptr);
+ return InterlockedRead64 ((volatile gint64 *)ptr);
}
void *
ves_icall_System_Threading_Volatile_ReadIntPtr (void *ptr)
{
- return InterlockedReadPointer (ptr);
+ return InterlockedReadPointer ((volatile gpointer *)ptr);
}
double
}
#endif
- u.ival = InterlockedRead64 (ptr);
+ u.ival = InterlockedRead64 ((volatile gint64 *)ptr);
return u.fval;
}
{
IntFloatUnion u;
- u.ival = InterlockedRead (ptr);
+ u.ival = InterlockedRead ((volatile gint32 *)ptr);
return u.fval;
}
MonoObject*
ves_icall_System_Threading_Volatile_Read_T (void *ptr)
{
- return InterlockedReadPointer (ptr);
+ return (MonoObject *)InterlockedReadPointer ((volatile gpointer *)ptr);
}
void
void
ves_icall_System_Threading_Volatile_Write1 (void *ptr, gint8 value)
{
- InterlockedWrite8 (ptr, value);
+ InterlockedWrite8 ((volatile gint8 *)ptr, value);
}
void
ves_icall_System_Threading_Volatile_Write2 (void *ptr, gint16 value)
{
- InterlockedWrite16 (ptr, value);
+ InterlockedWrite16 ((volatile gint16 *)ptr, value);
}
void
ves_icall_System_Threading_Volatile_Write4 (void *ptr, gint32 value)
{
- InterlockedWrite (ptr, value);
+ InterlockedWrite ((volatile gint32 *)ptr, value);
}
void
}
#endif
- InterlockedWrite64 (ptr, value);
+ InterlockedWrite64 ((volatile gint64 *)ptr, value);
}
void
ves_icall_System_Threading_Volatile_WriteIntPtr (void *ptr, void *value)
{
- InterlockedWritePointer (ptr, value);
+ InterlockedWritePointer ((volatile gpointer *)ptr, value);
}
void
u.fval = value;
- InterlockedWrite64 (ptr, u.ival);
+ InterlockedWrite64 ((volatile gint64 *)ptr, u.ival);
}
void
u.fval = value;
- InterlockedWrite (ptr, u.ival);
+ InterlockedWrite ((volatile gint32 *)ptr, u.ival);
}
void
{
struct wait_data *wait=(struct wait_data *)user;
MonoNativeThreadId self = mono_native_thread_id_get ();
- MonoInternalThread *thread = value;
+ MonoInternalThread *thread = (MonoInternalThread *)value;
HANDLE handle;
if (wait->num >= MAXIMUM_WAIT_OBJECTS)
static gboolean
collect_frame (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
- ThreadDumpUserData *ud = data;
+ ThreadDumpUserData *ud = (ThreadDumpUserData *)data;
if (ud->nframes < ud->max_frames) {
memcpy (&ud->frames [ud->nframes], frame, sizeof (MonoStackFrameInfo));
static SuspendThreadResult
get_thread_dump (MonoThreadInfo *info, gpointer ud)
{
- ThreadDumpUserData *user_data = ud;
+ ThreadDumpUserData *user_data = (ThreadDumpUserData *)ud;
MonoInternalThread *thread = user_data->thread;
#if 0
static void
collect_thread (gpointer key, gpointer value, gpointer user)
{
- CollectThreadsUserData *ud = user;
- MonoInternalThread *thread = value;
+ CollectThreadsUserData *ud = (CollectThreadsUserData *)user;
+ MonoInternalThread *thread = (MonoInternalThread *)value;
if (ud->nthreads < ud->max_threads)
ud->threads [ud->nthreads ++] = thread;
static void
ref_stack_destroy (gpointer ptr)
{
- RefStack *rs = ptr;
+ RefStack *rs = (RefStack *)ptr;
if (rs != NULL) {
g_free (rs->refs);
g_assert (rs != NULL);
if (rs->bottom >= rs->allocated) {
- rs->refs = g_realloc (rs->refs, rs->allocated * 2 * sizeof (gpointer) + 1);
+ rs->refs = (void **)g_realloc (rs->refs, rs->allocated * 2 * sizeof (gpointer) + 1);
rs->allocated <<= 1;
rs->refs [rs->allocated] = NULL;
}
SPIN_LOCK (thread->lock_thread_id);
if (thread->appdomain_refs == NULL)
thread->appdomain_refs = ref_stack_new (16);
- ref_stack_push (thread->appdomain_refs, domain);
+ ref_stack_push ((RefStack *)thread->appdomain_refs, domain);
SPIN_UNLOCK (thread->lock_thread_id);
}
}
if (thread) {
/* printf ("POP REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, ((MonoDomain*)(thread->appdomain_refs->data))->friendly_name); */
SPIN_LOCK (thread->lock_thread_id);
- ref_stack_pop (thread->appdomain_refs);
+ ref_stack_pop ((RefStack *)thread->appdomain_refs);
SPIN_UNLOCK (thread->lock_thread_id);
}
}
{
gboolean res;
SPIN_LOCK (thread->lock_thread_id);
- res = ref_stack_find (thread->appdomain_refs, domain);
+ res = ref_stack_find ((RefStack *)thread->appdomain_refs, domain);
SPIN_UNLOCK (thread->lock_thread_id);
return res;
}
static void
mark_slots (void *addr, MonoBitSet **bitmaps, MonoGCMarkFunc mark_func, void *gc_data)
{
- gpointer *static_data = addr;
+ gpointer *static_data = (gpointer *)addr;
for (int i = 0; i < NUM_STATIC_DATA_IDX; ++i) {
- void **ptr = static_data [i];
+ void **ptr = (void **)static_data [i];
if (!ptr)
continue;
ctx_desc = mono_gc_make_root_descr_user (mark_ctx_slots);
}
- static_data = mono_gc_alloc_fixed (static_data_size [0], threadlocal ? tls_desc : ctx_desc,
+ static_data = (void **)mono_gc_alloc_fixed (static_data_size [0], threadlocal ? tls_desc : ctx_desc,
threadlocal ? MONO_ROOT_SOURCE_THREAD_STATIC : MONO_ROOT_SOURCE_CONTEXT_STATIC,
threadlocal ? "managed thread-static variables" : "managed context-static variables");
*static_data_ptr = static_data;
static void
alloc_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
{
- MonoInternalThread *thread = value;
+ MonoInternalThread *thread = (MonoInternalThread *)value;
guint32 offset = GPOINTER_TO_UINT (user);
mono_alloc_static_data (&(thread->static_data), offset, TRUE);
static void
free_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
{
- MonoInternalThread *thread = value;
- OffsetSize *data = user;
+ MonoInternalThread *thread = (MonoInternalThread *)value;
+ OffsetSize *data = (OffsetSize *)user;
int idx = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, index);
int off = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, offset);
char *ptr;
return TRUE; // Remove this key/value pair
}
- OffsetSize *data = user;
+ OffsetSize *data = (OffsetSize *)user;
int idx = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, index);
int off = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, offset);
char *ptr;
static void
do_free_special (gpointer key, gpointer value, gpointer data)
{
- MonoClassField *field = key;
+ MonoClassField *field = (MonoClassField *)key;
guint32 offset = GPOINTER_TO_UINT (value);
gint32 align;
guint32 size;
static gboolean
last_managed (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
- MonoJitInfo **dest = data;
+ MonoJitInfo **dest = (MonoJitInfo **)data;
*dest = frame->ji;
return TRUE;
}
static SuspendThreadResult
abort_thread_critical (MonoThreadInfo *info, gpointer ud)
{
- AbortThreadData *data = ud;
+ AbortThreadData *data = (AbortThreadData *)ud;
MonoInternalThread *thread = data->thread;
MonoJitInfo *ji = NULL;
gboolean protected_wrapper;
static SuspendThreadResult
suspend_thread_critical (MonoThreadInfo *info, gpointer ud)
{
- SuspendThreadData *data = ud;
+ SuspendThreadData *data = (SuspendThreadData *)ud;
MonoInternalThread *thread = data->thread;
MonoJitInfo *ji = NULL;
gboolean protected_wrapper;
if (InterlockedCompareExchange (&thread->interruption_requested, 1, 0) == 0)
InterlockedIncrement (&thread_interruption_requested);
if (data->interrupt)
- data->interrupt_token = mono_thread_info_prepare_interrupt (thread->thread_info);
+ data->interrupt_token = mono_thread_info_prepare_interrupt ((MonoThreadInfo *)thread->thread_info);
if (mono_thread_notify_pending_exc_fn && !running_managed)
/* The JIT will notify the thread about the interruption */
mono_bool
mono_thread_is_foreign (MonoThread *thread)
{
- MonoThreadInfo *info = thread->internal_thread->thread_info;
+ MonoThreadInfo *info = (MonoThreadInfo *)thread->internal_thread->thread_info;
return info->runtime_thread == FALSE;
}
*
*/
static gboolean
-mono_type_is_value_type (MonoType *type, const char *namespace, const char *name)
+mono_type_is_value_type (MonoType *type, const char *namespace_, const char *name)
{
return type->type == MONO_TYPE_VALUETYPE &&
- !strcmp (namespace, type->data.klass->name_space) &&
+ !strcmp (namespace_, type->data.klass->name_space) &&
!strcmp (name, type->data.klass->name);
}
MonoClass *klass = NULL;
if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
- field = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+ field = (MonoClassField *)mono_method_get_wrapper_data (ctx->method, (guint32)token);
klass = field ? field->parent : NULL;
} else {
if (!IS_FIELD_DEF_OR_REF (token) || !token_bounds_check (ctx->image, token)) {
if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
- method = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+ method = (MonoMethod *)mono_method_get_wrapper_data (ctx->method, (guint32)token);
} else {
MonoError error;
if (!IS_METHOD_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
MonoType* type;
if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
- MonoClass *klass = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+ MonoClass *klass = (MonoClass *)mono_method_get_wrapper_data (ctx->method, (guint32)token);
type = klass ? &klass->byval_arg : NULL;
} else {
MonoError error;
GSList *tmp;
for (tmp = list; tmp; tmp = tmp->next) {
- info = tmp->data;
+ info = (MonoVerifyInfoExtended *)tmp->data;
g_free (info->info.message);
g_free (info);
}
if (mono_type_is_generic_argument (constraint_type)) {
MonoGenericParam *param = get_generic_param (ctx, constraint_type);
- MonoClass **class;
+ MonoClass **klass;
if (!param)
return FALSE;
- for (class = mono_generic_param_info (param)->constraints; class && *class; ++class) {
- if (recursive_boxed_constraint_type_check (ctx, type, *class, recursion_level - 1))
+ for (klass = mono_generic_param_info (param)->constraints; klass && *klass; ++klass) {
+ if (recursive_boxed_constraint_type_check (ctx, type, *klass, recursion_level - 1))
return TRUE;
}
}
if (mono_type_is_generic_argument (candidate)) {
MonoGenericParam *param = get_generic_param (ctx, candidate);
- MonoClass **class;
+ MonoClass **klass;
if (!param)
return FALSE;
- for (class = mono_generic_param_info (param)->constraints; class && *class; ++class) {
+ for (klass = mono_generic_param_info (param)->constraints; klass && *klass; ++klass) {
/*256 should be enough since there can't be more than 255 generic arguments.*/
- if (recursive_boxed_constraint_type_check (ctx, type, *class, 256))
+ if (recursive_boxed_constraint_type_check (ctx, type, *klass, 256))
return TRUE;
}
}
* TODO handle calling .ctor outside one or calling the .ctor for other class but super
*/
static void
-do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual)
+do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual_)
{
MonoError error;
int param_count, i;
gboolean virt_check_this = FALSE;
gboolean constrained = ctx->prefix_set & PREFIX_CONSTRAINED;
- if (!(method = verifier_load_method (ctx, method_token, virtual ? "callvirt" : "call")))
+ if (!(method = verifier_load_method (ctx, method_token, virtual_ ? "callvirt" : "call")))
return;
- if (virtual) {
+ if (virtual_) {
CLEAR_PREFIX (ctx, PREFIX_CONSTRAINED);
if (method->klass->valuetype) // && !constrained ???
}
if (stack_slot_is_managed_mutability_pointer (value))
- CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use a readonly pointer as argument of %s at 0x%04x", virtual ? "callvirt" : "call", ctx->ip_offset));
+ CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use a readonly pointer as argument of %s at 0x%04x", virtual_ ? "callvirt" : "call", ctx->ip_offset));
if ((ctx->prefix_set & PREFIX_TAIL) && stack_slot_is_managed_pointer (value)) {
- ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Cannot pass a byref argument to a tail %s at 0x%04x", virtual ? "callvirt" : "call", ctx->ip_offset));
+ ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Cannot pass a byref argument to a tail %s at 0x%04x", virtual_ ? "callvirt" : "call", ctx->ip_offset));
return;
}
}
if (virt_check_this && !stack_slot_is_this_pointer (value) && !(method->klass->valuetype || stack_slot_is_boxed_value (value)))
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use the call opcode with a non-final virtual method on an object different than the 'this' pointer at 0x%04x", ctx->ip_offset));
- if (constrained && virtual) {
+ if (constrained && virtual_) {
if (!stack_slot_is_managed_pointer (value))
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Object is not a managed pointer for a constrained call at 0x%04x", ctx->ip_offset));
if (!mono_metadata_type_equal_full (mono_type_get_type_byval (value->type), mono_type_get_underlying_type (ctx->constrained_type), TRUE))
if (stack_slot_is_managed_pointer (value) && !mono_class_from_mono_type (value->type)->valuetype)
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot call a reference type using a managed pointer to the this arg at 0x%04x", ctx->ip_offset));
- if (!virtual && mono_class_from_mono_type (value->type)->valuetype && !method->klass->valuetype && !stack_slot_is_boxed_value (value))
+ if (!virtual_ && mono_class_from_mono_type (value->type)->valuetype && !method->klass->valuetype && !stack_slot_is_boxed_value (value))
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot call a valuetype baseclass at 0x%04x", ctx->ip_offset));
- if (virtual && mono_class_from_mono_type (value->type)->valuetype && !stack_slot_is_boxed_value (value))
+ if (virtual_ && mono_class_from_mono_type (value->type)->valuetype && !stack_slot_is_boxed_value (value))
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use a valuetype with callvirt at 0x%04x", ctx->ip_offset));
if (method->klass->valuetype && (stack_slot_is_boxed_value (value) || !stack_slot_is_managed_pointer (value)))
if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
handle = mono_method_get_wrapper_data (ctx->method, token);
- handle_class = mono_method_get_wrapper_data (ctx->method, token + 1);
+ handle_class = (MonoClass *)mono_method_get_wrapper_data (ctx->method, token + 1);
if (handle_class == mono_defaults.typehandle_class)
handle = &((MonoClass*)handle)->byval_arg;
} else {
}
static void
-do_load_function_ptr (VerifyContext *ctx, guint32 token, gboolean virtual)
+do_load_function_ptr (VerifyContext *ctx, guint32 token, gboolean virtual_)
{
ILStackDesc *top;
MonoMethod *method;
- if (virtual && !check_underflow (ctx, 1))
+ if (virtual_ && !check_underflow (ctx, 1))
return;
- if (!virtual && !check_overflow (ctx))
+ if (!virtual_ && !check_overflow (ctx))
return;
if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
- method = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+ method = (MonoMethod *)mono_method_get_wrapper_data (ctx->method, (guint32)token);
if (!method) {
ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid token %x for ldftn at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
return;
return;
}
- if (!(method = verifier_load_method (ctx, token, virtual ? "ldvirtfrn" : "ldftn")))
+ if (!(method = verifier_load_method (ctx, token, virtual_ ? "ldvirtfrn" : "ldftn")))
return;
}
if (mono_method_is_constructor (method))
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use ldftn with a constructor at 0x%04x", ctx->ip_offset));
- if (virtual) {
+ if (virtual_) {
ILStackDesc *top = stack_pop (ctx);
if (stack_slot_get_type (top) != TYPE_COMPLEX || top->type->type == MONO_TYPE_VALUETYPE)
memset(ctx.code, 0, sizeof (ILCodeDesc) * ctx.header->code_size);
ctx.num_locals = ctx.header->num_locals;
- ctx.locals = g_memdup (ctx.header->locals, sizeof (MonoType*) * ctx.header->num_locals);
+ ctx.locals = (MonoType **)g_memdup (ctx.header->locals, sizeof (MonoType*) * ctx.header->num_locals);
_MEM_ALLOC (sizeof (MonoType*) * ctx.header->num_locals);
if (ctx.num_locals > 0 && !ctx.header->init_locals)
g_slist_free (ctx.funptrs);
for (tmp = ctx.exception_types; tmp; tmp = tmp->next)
- mono_metadata_free_type (tmp->data);
+ mono_metadata_free_type ((MonoType *)tmp->data);
g_slist_free (ctx.exception_types);
for (i = 0; i < ctx.num_locals; ++i) {
static guint
field_hash (gconstpointer key)
{
- const MonoClassField *field = key;
+ const MonoClassField *field = (const MonoClassField *)key;
return g_str_hash (field->name) ^ mono_metadata_type_hash (field->type); /**/
}
static gboolean
field_equals (gconstpointer _a, gconstpointer _b)
{
- const MonoClassField *a = _a;
- const MonoClassField *b = _b;
+ const MonoClassField *a = (const MonoClassField *)_a;
+ const MonoClassField *b = (const MonoClassField *)_b;
return !strcmp (a->name, b->name) && mono_metadata_type_equal (a->type, b->type);
}
(r)->next = NULL;\
} while (0)
-#define MONO_NEGATED_RELATION(r) ((~(r))&MONO_ANY_RELATION)
-#define MONO_SYMMETRIC_RELATION(r) (((r)&MONO_EQ_RELATION)|(((r)&MONO_LT_RELATION)<<1)|((r&MONO_GT_RELATION)>>1))
+#define MONO_NEGATED_RELATION(r) ((MonoValueRelation)((~(r))&MONO_ANY_RELATION))
+#define MONO_SYMMETRIC_RELATION(r) ((MonoValueRelation)(((r)&MONO_EQ_RELATION)|(((r)&MONO_LT_RELATION)<<1)|((r&MONO_GT_RELATION)>>1)))
current_context = father_context;
while (current_context != last_context) {
- current_context->status |= recursive_status;
+ current_context->status = (MonoRelationsEvaluationStatus)(current_context->status | recursive_status);
current_context = current_context->father;
}
} else {
{
MonoAdditionalVariableRelation *rel;
- rel = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoAdditionalVariableRelation));
+ rel = (MonoAdditionalVariableRelation *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoAdditionalVariableRelation));
rel->variable = reg;
rel->relation.relation = MONO_GT_RELATION;
rel->relation.related_value.type = MONO_CONSTANT_SUMMARIZED_VALUE;
/* We can derive additional relations from the bounds check */
if (ins->opcode != OP_NOP) {
- rel = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoAdditionalVariableRelation));
+ rel = (MonoAdditionalVariableRelation *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoAdditionalVariableRelation));
rel->variable = index_var;
rel->relation.relation = MONO_LT_RELATION;
rel->relation.related_value.type = MONO_VARIABLE_SUMMARIZED_VALUE;
check_relations = g_slist_append_mempool (cfg->mempool, check_relations, rel);
- rel = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoAdditionalVariableRelation));
+ rel = (MonoAdditionalVariableRelation *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoAdditionalVariableRelation));
rel->variable = index_var;
rel->relation.relation = MONO_GE_RELATION;
rel->relation.related_value.type = MONO_CONSTANT_SUMMARIZED_VALUE;
}
for (l = check_relations; l; l = l->next)
- remove_change_from_evaluation_area (l->data);
+ remove_change_from_evaluation_area ((MonoAdditionalVariableRelation *)l->data);
remove_change_from_evaluation_area (&(additional_relations.relation1));
remove_change_from_evaluation_area (&(additional_relations.relation2));
return MONO_UNSIGNED_INTEGER_VALUE_SIZE_4;
break;
case MONO_TYPE_I:
- return SIZEOF_VOID_P;
+ return (MonoIntegerValueKind)SIZEOF_VOID_P;
break;
case MONO_TYPE_U:
- return (MONO_UNSIGNED_VALUE_FLAG|SIZEOF_VOID_P);
+ return (MonoIntegerValueKind)(MONO_UNSIGNED_VALUE_FLAG | SIZEOF_VOID_P);
break;
case MONO_TYPE_I8:
return MONO_INTEGER_VALUE_SIZE_8;
mono_mempool_alloc (cfg->mempool, sizeof (MonoRelationsEvaluationContext) * (cfg->next_vreg));
area.variable_value_kind = (MonoIntegerValueKind *)
mono_mempool_alloc (cfg->mempool, sizeof (MonoIntegerValueKind) * (cfg->next_vreg));
- area.defs = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * cfg->next_vreg);
+ area.defs = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * cfg->next_vreg);
for (i = 0; i < cfg->next_vreg; i++) {
area.variable_value_kind [i] = MONO_UNKNOWN_INTEGER_VALUE;
area.relations [i].relation = MONO_EQ_RELATION;
static gboolean
lower_load (MonoCompile *cfg, MonoInst *load, MonoInst *ldaddr)
{
- MonoInst *var = ldaddr->inst_p0;
+ MonoInst *var = (MonoInst *)ldaddr->inst_p0;
MonoType *type = &var->klass->byval_arg;
int replaced_op = mono_type_to_load_membase (cfg, type);
static gboolean
lower_store (MonoCompile *cfg, MonoInst *store, MonoInst *ldaddr)
{
- MonoInst *var = ldaddr->inst_p0;
+ MonoInst *var = (MonoInst *)ldaddr->inst_p0;
MonoType *type = &var->klass->byval_arg;
int replaced_op = mono_type_to_store_membase (cfg, type);
static gboolean
lower_store_imm (MonoCompile *cfg, MonoInst *store, MonoInst *ldaddr)
{
- MonoInst *var = ldaddr->inst_p0;
+ MonoInst *var = (MonoInst *)ldaddr->inst_p0;
MonoType *type = &var->klass->byval_arg;
int store_op = mono_type_to_store_membase (cfg, type);
if (store_op == OP_STOREV_MEMBASE || store_op == OP_STOREX_MEMBASE)
case OP_LOADR8_MEMBASE:
if (ins->inst_offset != 0)
continue;
- tmp = g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->sreg1));
+ tmp = (MonoInst *)g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->sreg1));
if (tmp) {
if (cfg->verbose_level > 2) { printf ("Found candidate load:"); mono_print_ins (ins); }
if (lower_load (cfg, ins, tmp)) {
case OP_STOREV_MEMBASE:
if (ins->inst_offset != 0)
continue;
- tmp = g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->dreg));
+ tmp = (MonoInst *)g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->dreg));
if (tmp) {
if (cfg->verbose_level > 2) { printf ("Found candidate store:"); mono_print_ins (ins); }
if (lower_store (cfg, ins, tmp)) {
case OP_STOREI8_MEMBASE_IMM:
if (ins->inst_offset != 0)
continue;
- tmp = g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->dreg));
+ tmp = (MonoInst *)g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->dreg));
if (tmp) {
if (cfg->verbose_level > 2) { printf ("Found candidate store-imm:"); mono_print_ins (ins); }
needs_dce |= lower_store_imm (cfg, ins, tmp);
break;
case OP_CHECK_THIS:
case OP_NOT_NULL:
- tmp = g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->sreg1));
+ tmp = (MonoInst *)g_hash_table_lookup (addr_loads, GINT_TO_POINTER (ins->sreg1));
if (tmp) {
if (cfg->verbose_level > 2) { printf ("Found null check over local: "); mono_print_ins (ins); }
NULLIFY_INS (ins);
const int kSizeOfMove = 7;
#if defined(__default_codegen__)
- code = buf = g_malloc (256);
+ code = buf = (guint8 *)g_malloc (256);
#elif defined(__native_client_codegen__)
buf_alloc = g_malloc (256 + kNaClAlignment + kSizeOfMove);
buf = ((guint)buf_alloc + kNaClAlignment) & ~kNaClAlignmentMask;
{
sh->index = 0;
sh->alloc_size = 4096;
- sh->data = g_malloc (4096);
+ sh->data = (char *)g_malloc (4096);
/* So offsets are > 0 */
sh->data [0] = 0;
stream->alloc_size *= 2;
}
- stream->data = g_realloc (stream->data, stream->alloc_size);
+ stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
}
static guint32
index_offsets = g_new0 (guint32, ngroups);
buf_size = noffsets * 4;
- p = buf = g_malloc0 (buf_size);
+ p = buf = (guint8 *)g_malloc0 (buf_size);
current_offset = 0;
for (i = 0; i < noffsets; ++i) {
index_entry_size = 4;
buf_size = (data_p - data_buf) + (ngroups * 4) + 16;
- p = buf = g_malloc0 (buf_size);
+ p = buf = (guint8 *)g_malloc0 (buf_size);
/* Emit the header */
encode_int (noffsets, p, &p);
/* FIXME: Search referenced images as well */
if (!acfg->typespec_classes) {
- acfg->typespec_classes = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoClass*) * len);
+ acfg->typespec_classes = (MonoClass **)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoClass*) * len);
for (i = 0; i < len; ++i) {
MonoError error;
acfg->typespec_classes [i] = mono_class_get_and_inflate_typespec_checked (acfg->image, MONO_TOKEN_TYPE_SPEC | (i + 1), NULL, &error);
guint8 *buf2, *p;
if (!offset) {
- buf2 = g_malloc (1024);
+ buf2 = (guint8 *)g_malloc (1024);
p = buf2;
encode_klass_ref_inner (acfg, klass, p, &p);
* encode that.
* Obtain the token from information recorded by the JIT.
*/
- ji = g_hash_table_lookup (acfg->token_info_hash, method);
+ ji = (MonoJumpInfoToken *)g_hash_table_lookup (acfg->token_info_hash, method);
if (ji) {
image_index = get_image_index (acfg, ji->image);
g_assert (image_index < MAX_IMAGE_INDEX);
} else if (token == 0) {
/* This might be a method of a constructed type like int[,].Set */
/* Obtain the token from information recorded by the JIT */
- ji = g_hash_table_lookup (acfg->token_info_hash, method);
+ ji = (MonoJumpInfoToken *)g_hash_table_lookup (acfg->token_info_hash, method);
if (ji) {
image_index = get_image_index (acfg, ji->image);
g_assert (image_index < MAX_IMAGE_INDEX);
if (!acfg->patch_to_plt_entry [patch_info->type])
acfg->patch_to_plt_entry [patch_info->type] = g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
- res = g_hash_table_lookup (acfg->patch_to_plt_entry [patch_info->type], patch_info);
+ res = (MonoPltEntry *)g_hash_table_lookup (acfg->patch_to_plt_entry [patch_info->type], patch_info);
if (!acfg->llvm && patch_info->type == MONO_PATCH_INFO_METHOD && (patch_info->data.method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)) {
/*
new_ji = mono_patch_info_dup_mp (acfg->mempool, patch_info);
- res = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoPltEntry));
+ res = (MonoPltEntry *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoPltEntry));
res->plt_offset = acfg->plt_offset;
res->ji = new_ji;
res->symbol = get_plt_symbol (acfg, res->plt_offset, patch_info);
static void
add_jit_icall_wrapper (gpointer key, gpointer value, gpointer user_data)
{
- MonoAotCompile *acfg = user_data;
- MonoJitICallInfo *callinfo = value;
+ MonoAotCompile *acfg = (MonoAotCompile *)user_data;
+ MonoJitICallInfo *callinfo = (MonoJitICallInfo *)value;
MonoMethod *wrapper;
char *name;
}
static MonoMethod*
-get_runtime_invoke (MonoAotCompile *acfg, MonoMethod *method, gboolean virtual)
+get_runtime_invoke (MonoAotCompile *acfg, MonoMethod *method, gboolean virtual_)
{
- return mono_marshal_get_runtime_invoke (method, virtual, acfg->aot_opts.llvm_only && mono_method_needs_static_rgctx_invoke (method, TRUE));
+ return mono_marshal_get_runtime_invoke (method, virtual_, acfg->aot_opts.llvm_only && mono_method_needs_static_rgctx_invoke (method, TRUE));
}
static gboolean
/* From load_cattr_value () in reflection.c */
slen = mono_metadata_decode_value (p, &p);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, acfg->image);
g_assert (t);
named += 1;
name_len = mono_metadata_decode_blob_size (named, &named);
- name = g_malloc (name_len + 1);
+ name = (char *)g_malloc (name_len + 1);
memcpy (name, named, name_len);
name [name_len] = 0;
named += name_len;
/* load_cattr_value (), string case */
g_assert (*named != (char)0xff);
slen = mono_metadata_decode_value (named, &named);
- export_name = g_malloc (slen + 1);
+ export_name = (char *)g_malloc (slen + 1);
memcpy (export_name, named, slen);
export_name [slen] = 0;
named += slen;
/* Add types of args/locals */
for (i = 0; i < acfg->methods->len; ++i) {
- method = g_ptr_array_index (acfg->methods, i);
+ method = (MonoMethod *)g_ptr_array_index (acfg->methods, i);
add_types_from_method_header (acfg, method);
}
is_direct_callable (MonoAotCompile *acfg, MonoMethod *method, MonoJumpInfo *patch_info)
{
if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (patch_info->data.method->klass->image == acfg->image)) {
- MonoCompile *callee_cfg = g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
+ MonoCompile *callee_cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
if (callee_cfg) {
gboolean direct_callable = TRUE;
guint32 im_cols [MONO_IMPLMAP_SIZE];
char *import;
- import = g_hash_table_lookup (acfg->method_to_pinvoke_import, method);
+ import = (char *)g_hash_table_lookup (acfg->method_to_pinvoke_import, method);
if (import != NULL)
return import;
ln_array = g_new0 (MonoDebugLineNumberEntry, debug_info->num_line_numbers);
memcpy (ln_array, debug_info->line_numbers, debug_info->num_line_numbers * sizeof (MonoDebugLineNumberEntry));
- qsort (ln_array, debug_info->num_line_numbers, sizeof (MonoDebugLineNumberEntry), (gpointer)compare_lne);
+ qsort (ln_array, debug_info->num_line_numbers, sizeof (MonoDebugLineNumberEntry), (int (*)(const void *, const void *))compare_lne);
native_to_il_offset = g_new0 (int, code_size + 1);
for (i = 0; i < code_len; i += INST_LEN) {
patch_info = NULL;
for (pindex = start_index; pindex < patches->len; ++pindex) {
- patch_info = g_ptr_array_index (patches, pindex);
+ patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
if (patch_info->ip.i >= i)
break;
}
}
case MONO_PATCH_INFO_OBJC_SELECTOR_REF: {
int code_size, index;
- char *selector = (void*)patch_info->data.target;
+ char *selector = (char *)patch_info->data.target;
if (!acfg->objc_selector_to_index)
acfg->objc_selector_to_index = g_hash_table_new (g_str_hash, g_str_equal);
external_call = FALSE;
if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (patch_info->data.method->klass->image == acfg->image)) {
if (!got_only && is_direct_callable (acfg, method, patch_info)) {
- MonoCompile *callee_cfg = g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
+ MonoCompile *callee_cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
//printf ("DIRECT: %s %s\n", method ? mono_method_full_name (method, TRUE) : "", mono_method_full_name (callee_cfg->method, TRUE));
direct_call = TRUE;
direct_call_target = callee_cfg->asm_symbol;
/* Find next patch */
patch_info = NULL;
for (pindex = start_index; pindex < patches->len; ++pindex) {
- patch_info = g_ptr_array_index (patches, pindex);
+ patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
if (patch_info->ip.i >= i)
break;
}
#endif
len = strlen (name1);
- name2 = malloc (strlen (prefix) + len + 16);
+ name2 = (char *)malloc (strlen (prefix) + len + 16);
memcpy (name2, prefix, strlen (prefix));
j = strlen (prefix);
for (i = 0; i < len; ++i) {
count = 0;
while (TRUE) {
- cached_method = g_hash_table_lookup (cache, name2);
+ cached_method = (MonoMethod *)g_hash_table_lookup (cache, name2);
if (!(cached_method && cached_method != method))
break;
sprintf (name2 + j, "_%d", count);
emit_label (acfg, debug_sym);
}
- export_name = g_hash_table_lookup (acfg->export_names, method);
+ export_name = (char *)g_hash_table_lookup (acfg->export_names, method);
if (export_name) {
/* Emit a global symbol for the method */
emit_global_inner (acfg, export_name, TRUE);
ex_class =
mono_class_from_name (mono_defaults.exception_class->image,
- "System", patch_info->data.target);
+ "System", (const char *)patch_info->data.target);
g_assert (ex_class);
encode_klass_ref (acfg, ex_class, p, &p);
break;
*/
offset = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_blob_hash, entry->method));
if (!offset) {
- buf2 = g_malloc (1024);
+ buf2 = (guint8 *)g_malloc (1024);
p2 = buf2;
encode_method_ref (acfg, entry->method, p2, &p2);
encode_method_ref (acfg, info->method, p, &p);
encode_value (info->num_entries, p, &p);
for (i = 0; i < info->num_entries; ++i) {
- MonoRuntimeGenericContextInfoTemplate *template = &info->entries [i];
+ MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
- encode_value (template->info_type, p, &p);
- switch (mini_rgctx_info_type_to_patch_info_type (template->info_type)) {
+ encode_value (template_->info_type, p, &p);
+ switch (mini_rgctx_info_type_to_patch_info_type (template_->info_type)) {
case MONO_PATCH_INFO_CLASS:
- encode_klass_ref (acfg, mono_class_from_mono_type (template->data), p, &p);
+ encode_klass_ref (acfg, mono_class_from_mono_type ((MonoType *)template_->data), p, &p);
break;
case MONO_PATCH_INFO_FIELD:
- encode_field_info (acfg, template->data, p, &p);
+ encode_field_info (acfg, (MonoClassField *)template_->data, p, &p);
break;
default:
g_assert_not_reached ();
break;
}
case MONO_PATCH_INFO_LDSTR_LIT: {
- const char *s = patch_info->data.target;
+ const char *s = (const char *)patch_info->data.target;
int len = strlen (s);
encode_value (len, p, &p);
encode_value (n_patches, p, &p);
for (pindex = 0; pindex < patches->len; ++pindex) {
- patch_info = g_ptr_array_index (patches, pindex);
+ patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
if (patch_info->type == MONO_PATCH_INFO_NONE || patch_info->type == MONO_PATCH_INFO_BB)
/* Nothing to do */
/**********************/
buf_size = (patches->len < 1000) ? 40960 : 40960 + (patches->len * 64);
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
if (mono_class_get_cctor (method->klass))
encode_klass_ref (acfg, method->klass, p, &p);
n_patches = 0;
for (pindex = 0; pindex < patches->len; ++pindex) {
- patch_info = g_ptr_array_index (patches, pindex);
+ patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
if ((patch_info->type == MONO_PATCH_INFO_GOT_OFFSET) ||
(patch_info->type == MONO_PATCH_INFO_NONE)) {
buf_size = header->num_clauses * 256 + debug_info_size + 2048 + seq_points_size + cfg->gc_map_size;
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
use_unwind_ops = cfg->unwind_ops != NULL;
guint8 *buf2, *p2;
int len;
- buf2 = g_malloc (4096);
+ buf2 = (guint8 *)g_malloc (4096);
p2 = buf2;
encode_klass_ref (acfg, ei->data.catch_class, p2, &p2);
len = p2 - buf2;
* Need to encode jinfo->method too, since it is not equal to 'method'
* when using generic sharing.
*/
- buf2 = g_malloc (4096);
+ buf2 = (guint8 *)g_malloc (4096);
p2 = buf2;
encode_method_ref (acfg, jinfo->d.method, p2, &p2);
len = p2 - buf2;
buf_size = 16;
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
/* Mark as unusable */
encode_value (-1, p, &p);
}
buf_size = 10240 + (klass->vtable_size * 16);
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
g_assert (klass);
*/
continue;
- plt_entry = g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
+ plt_entry = (MonoPltEntry *)g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
debug_sym = plt_entry->debug_sym;
if (i == 0)
continue;
- plt_entry = g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
+ plt_entry = (MonoPltEntry *)g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
/* Skip plt entries not actually called by LLVM code */
if (!plt_entry->llvm_used)
g_ptr_array_sort (patches, compare_patches);
buf_size = patches->len * 128 + 128;
- buf = g_malloc (buf_size);
+ buf = (guint8 *)g_malloc (buf_size);
p = buf;
encode_patch_list (acfg, patches, patches->len, FALSE, got_offset, p, &p);
char symbol [256];
char end_symbol [256];
int i, tramp_got_offset;
- MonoAotTrampoline ntype;
+ int ntype;
#ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
int tramp_type;
#endif
if (tramp_type == MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD)
continue;
#endif
- mono_arch_create_generic_trampoline (tramp_type, &info, acfg->aot_opts.use_trampolines_page? 2: TRUE);
+ mono_arch_create_generic_trampoline ((MonoTrampolineType)tramp_type, &info, acfg->aot_opts.use_trampolines_page? 2: TRUE);
emit_trampoline (acfg, acfg->got_offset, info);
}
GSList *l = mono_arch_get_trampolines (TRUE);
while (l) {
- MonoTrampInfo *info = l->data;
+ MonoTrampInfo *info = (MonoTrampInfo *)l->data;
emit_trampoline (acfg, acfg->got_offset, info);
l = l->next;
/* delegate_invoke_impl trampolines */
l = mono_arch_get_delegate_invoke_impls ();
while (l) {
- MonoTrampInfo *info = l->data;
+ MonoTrampInfo *info = (MonoTrampInfo *)l->data;
emit_trampoline (acfg, acfg->got_offset, info);
l = l->next;
exit (1);
}
rdv = g_new0 (ReadOnlyValue, 1);
- rdv->name = g_malloc0 (tval - val + 1);
+ rdv->name = (char *)g_malloc0 (tval - val + 1);
memcpy (rdv->name, val, tval - val);
tval++;
fval++;
args = mono_aot_split_options (aot_options ? aot_options : "");
for (int i = 0; i < args->len; ++i) {
- const char *arg = g_ptr_array_index (args, i);
+ const char *arg = (const char *)g_ptr_array_index (args, i);
if (str_begins_with (arg, "outfile=")) {
opts->outfile = g_strdup (arg + strlen ("outfile="));
{
MonoMethod *method = (MonoMethod*)key;
MonoJumpInfoToken *ji = (MonoJumpInfoToken*)value;
- MonoAotCompile *acfg = user_data;
+ MonoAotCompile *acfg = (MonoAotCompile *)user_data;
MonoJumpInfoToken *new_ji;
- new_ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfoToken));
+ new_ji = (MonoJumpInfoToken *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfoToken));
new_ji->image = ji->image;
new_ji->token = ji->token;
g_hash_table_insert (acfg->token_info_hash, method, new_ji);
*/
flags = JIT_FLAG_AOT;
if (mono_aot_mode_is_full (&acfg->aot_opts))
- flags |= JIT_FLAG_FULL_AOT;
+ flags = (JitFlags)(flags | JIT_FLAG_FULL_AOT);
if (acfg->llvm)
- flags |= JIT_FLAG_LLVM;
+ flags = (JitFlags)(flags | JIT_FLAG_LLVM);
if (acfg->aot_opts.llvm_only)
- flags |= JIT_FLAG_LLVM_ONLY | JIT_FLAG_EXPLICIT_NULL_CHECKS;
+ flags = (JitFlags)(flags | JIT_FLAG_LLVM_ONLY | JIT_FLAG_EXPLICIT_NULL_CHECKS);
if (acfg->aot_opts.no_direct_calls)
- flags |= JIT_FLAG_NO_DIRECT_ICALLS;
+ flags = (JitFlags)(flags | JIT_FLAG_NO_DIRECT_ICALLS);
cfg = mini_method_compile (method, acfg->opts, mono_get_root_domain (), flags, 0, index);
mono_loader_clear_error ();
unwind_ops = NULL;
for (l = cfg->unwind_ops; l; l = l->next) {
- op = mono_mempool_alloc (acfg->mempool, sizeof (MonoUnwindOp));
+ op = (MonoUnwindOp *)mono_mempool_alloc (acfg->mempool, sizeof (MonoUnwindOp));
memcpy (op, l->data, sizeof (MonoUnwindOp));
unwind_ops = g_slist_prepend_mempool (acfg->mempool, unwind_ops, op);
}
int i;
sig = mono_method_signature (method);
- args = mono_mempool_alloc (acfg->mempool, sizeof (MonoInst*) * (sig->param_count + sig->hasthis));
+ args = (MonoInst **)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst*) * (sig->param_count + sig->hasthis));
for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
- args [i] = mono_mempool_alloc (acfg->mempool, sizeof (MonoInst));
+ args [i] = (MonoInst *)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst));
memcpy (args [i], cfg->args [i], sizeof (MonoInst));
}
cfg->args = args;
header = mono_method_get_header (method);
- locals = mono_mempool_alloc (acfg->mempool, sizeof (MonoInst*) * header->num_locals);
+ locals = (MonoInst **)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst*) * header->num_locals);
for (i = 0; i < header->num_locals; ++i) {
- locals [i] = mono_mempool_alloc (acfg->mempool, sizeof (MonoInst));
+ locals [i] = (MonoInst *)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst));
memcpy (locals [i], cfg->locals [i], sizeof (MonoInst));
}
cfg->locals = locals;
static void
compile_thread_main (gpointer *user_data)
{
- MonoDomain *domain = user_data [0];
- MonoAotCompile *acfg = user_data [1];
- GPtrArray *methods = user_data [2];
+ MonoDomain *domain = (MonoDomain *)user_data [0];
+ MonoAotCompile *acfg = (MonoAotCompile *)user_data [1];
+ GPtrArray *methods = (GPtrArray *)user_data [2];
int i;
mono_thread_attach (domain);
for (i = 0; i < methods->len; ++i)
- compile_method (acfg, g_ptr_array_index (methods, i));
+ compile_method (acfg, (MonoMethod *)g_ptr_array_index (methods, i));
}
static void
if (llvm_acfg->aot_opts.direct_icalls) {
if (type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
/* Call to a C function implementing a jit icall */
- sym = mono_lookup_jit_icall_symbol (data);
+ sym = mono_lookup_jit_icall_symbol ((const char *)data);
} else if (type == MONO_PATCH_INFO_ICALL_ADDR) {
- MonoMethod *method = (gpointer)data;
+ MonoMethod *method = (MonoMethod *)data;
if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
sym = mono_lookup_icall_symbol (method);
}
char*
mono_aot_get_plt_symbol (MonoJumpInfoType type, gconstpointer data)
{
- MonoJumpInfo *ji = mono_mempool_alloc (llvm_acfg->mempool, sizeof (MonoJumpInfo));
+ MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc (llvm_acfg->mempool, sizeof (MonoJumpInfo));
MonoPltEntry *plt_entry;
const char *sym = NULL;
if (llvm_acfg->aot_opts.direct_icalls) {
if (type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
/* Call to a C function implementing a jit icall */
- sym = mono_lookup_jit_icall_symbol (data);
+ sym = mono_lookup_jit_icall_symbol ((const char *)data);
} else if (type == MONO_PATCH_INFO_ICALL_ADDR) {
- MonoMethod *method = (gpointer)data;
+ MonoMethod *method = (MonoMethod *)data;
if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
sym = mono_lookup_icall_symbol (method);
}
ginst = ((MonoMethodInflated*)method)->context.method_inst;
hashes_count = sig->param_count + 5 + (class_ginst ? class_ginst->type_argc : 0) + (ginst ? ginst->type_argc : 0);
- hashes_start = g_malloc0 (hashes_count * sizeof (guint32));
+ hashes_start = (guint32 *)g_malloc0 (hashes_count * sizeof (guint32));
hashes = hashes_start;
/* Some wrappers are assigned to random classes */
/* Emit method info */
nmethods = 0;
for (i = 0; i < acfg->extra_methods->len; ++i) {
- MonoMethod *method = g_ptr_array_index (acfg->extra_methods, i);
- MonoCompile *cfg = g_hash_table_lookup (acfg->method_to_cfg, method);
+ MonoMethod *method = (MonoMethod *)g_ptr_array_index (acfg->extra_methods, i);
+ MonoCompile *cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, method);
if (!cfg)
continue;
buf_size = 10240;
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
nmethods ++;
chain_lengths = g_new0 (int, table_size);
max_chain_length = 0;
for (i = 0; i < acfg->extra_methods->len; ++i) {
- MonoMethod *method = g_ptr_array_index (acfg->extra_methods, i);
- MonoCompile *cfg = g_hash_table_lookup (acfg->method_to_cfg, method);
+ MonoMethod *method = (MonoMethod *)g_ptr_array_index (acfg->extra_methods, i);
+ MonoCompile *cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, method);
guint32 key, value;
if (!cfg)
chain_lengths [hash] ++;
max_chain_length = MAX (max_chain_length, chain_lengths [hash]);
- new_entry = mono_mempool_alloc0 (acfg->mempool, sizeof (HashEntry));
+ new_entry = (HashEntry *)mono_mempool_alloc0 (acfg->mempool, sizeof (HashEntry));
new_entry->key = key;
new_entry->value = value;
- entry = g_ptr_array_index (table, hash);
+ entry = (HashEntry *)g_ptr_array_index (table, hash);
if (entry == NULL) {
new_entry->index = hash;
g_ptr_array_index (table, hash) = new_entry;
//printf ("MAX: %d\n", max_chain_length);
buf_size = table->len * 12 + 4;
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
encode_int (table_size, p, &p);
for (i = 0; i < table->len; ++i) {
- HashEntry *entry = g_ptr_array_index (table, i);
+ HashEntry *entry = (HashEntry *)g_ptr_array_index (table, i);
if (entry == NULL) {
encode_int (0, p, &p);
* This is used by mono_aot_find_jit_info ().
*/
buf_size = acfg->extra_methods->len * 8 + 4;
- p = buf = g_malloc (buf_size);
+ p = buf = (guint8 *)g_malloc (buf_size);
encode_int (acfg->extra_methods->len, p, &p);
for (i = 0; i < acfg->extra_methods->len; ++i) {
- MonoMethod *method = g_ptr_array_index (acfg->extra_methods, i);
+ MonoMethod *method = (MonoMethod *)g_ptr_array_index (acfg->extra_methods, i);
encode_int (get_method_index (acfg, method), p, &p);
encode_int (info_offsets [i], p, &p);
new_entry = g_new0 (ClassNameTableEntry, 1);
new_entry->token = token;
- entry = g_ptr_array_index (table, hash);
+ entry = (ClassNameTableEntry *)g_ptr_array_index (table, hash);
if (entry == NULL) {
new_entry->index = hash;
g_ptr_array_index (table, hash) = new_entry;
/* Emit the table */
buf_size = table->len * 4 + 4;
- p = buf = g_malloc0 (buf_size);
+ p = buf = (guint8 *)g_malloc0 (buf_size);
/* FIXME: Optimize memory usage */
g_assert (table_size < 65000);
encode_int16 (table_size, p, &p);
g_assert (table->len < 65000);
for (i = 0; i < table->len; ++i) {
- ClassNameTableEntry *entry = g_ptr_array_index (table, i);
+ ClassNameTableEntry *entry = (ClassNameTableEntry *)g_ptr_array_index (table, i);
if (entry == NULL) {
encode_int16 (0, p, &p);
buf_size += strlen (image->assembly_name) + strlen (image->guid) + (aname->culture ? strlen (aname->culture) : 1) + strlen ((char*)aname->public_key_token) + 4;
}
- buf = p = g_malloc0 (buf_size);
+ buf = p = (guint8 *)g_malloc0 (buf_size);
encode_int (acfg->image_table->len, p, &p);
for (i = 0; i < acfg->image_table->len; i++) {
MonoImage *image = (MonoImage*)g_ptr_array_index (acfg->image_table, i);
acfg->plt_got_offset_base = acfg->got_offset;
first_plt_got_patch = info->got_patches->len;
for (i = 1; i < acfg->plt_offset; ++i) {
- MonoPltEntry *plt_entry = g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
+ MonoPltEntry *plt_entry = (MonoPltEntry *)g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
g_ptr_array_add (info->got_patches, plt_entry->ji);
/* Encode info required to decode shared GOT entries */
buf_size = info->got_patches->len * 128;
- p = buf = mono_mempool_alloc (acfg->mempool, buf_size);
- got_info_offsets = mono_mempool_alloc (acfg->mempool, info->got_patches->len * sizeof (guint32));
+ p = buf = (guint8 *)mono_mempool_alloc (acfg->mempool, buf_size);
+ got_info_offsets = (guint32 *)mono_mempool_alloc (acfg->mempool, info->got_patches->len * sizeof (guint32));
if (!llvm) {
- acfg->plt_got_info_offsets = mono_mempool_alloc (acfg->mempool, acfg->plt_offset * sizeof (guint32));
+ acfg->plt_got_info_offsets = (guint32 *)mono_mempool_alloc (acfg->mempool, acfg->plt_offset * sizeof (guint32));
/* Unused */
if (acfg->plt_offset)
acfg->plt_got_info_offsets [0] = 0;
}
for (i = 0; i < info->got_patches->len; ++i) {
- MonoJumpInfo *ji = g_ptr_array_index (info->got_patches, i);
+ MonoJumpInfo *ji = (MonoJumpInfo *)g_ptr_array_index (info->got_patches, i);
guint8 *p2;
p = buf;
for (i = 0; i < table_size; ++i)
g_ptr_array_add (table, NULL);
for (i = 0; i < acfg->globals->len; ++i) {
- char *name = g_ptr_array_index (acfg->globals, i);
+ char *name = (char *)g_ptr_array_index (acfg->globals, i);
hash = mono_metadata_str_hash (name) % table_size;
new_entry = g_new0 (GlobalsTableEntry, 1);
new_entry->value = i;
- entry = g_ptr_array_index (table, hash);
+ entry = (GlobalsTableEntry *)g_ptr_array_index (table, hash);
if (entry == NULL) {
new_entry->index = hash;
g_ptr_array_index (table, hash) = new_entry;
g_assert (table_size < 65000);
emit_int16 (acfg, table_size);
for (i = 0; i < table->len; ++i) {
- GlobalsTableEntry *entry = g_ptr_array_index (table, i);
+ GlobalsTableEntry *entry = (GlobalsTableEntry *)g_ptr_array_index (table, i);
if (entry == NULL) {
emit_int16 (acfg, 0);
/* Emit the names */
for (i = 0; i < acfg->globals->len; ++i) {
- char *name = g_ptr_array_index (acfg->globals, i);
+ char *name = (char *)g_ptr_array_index (acfg->globals, i);
sprintf (symbol, "name_%d", i);
emit_section_change (acfg, RODATA_SECT, 1);
emit_pointer (acfg, symbol);
for (i = 0; i < acfg->globals->len; ++i) {
- char *name = g_ptr_array_index (acfg->globals, i);
+ char *name = (char *)g_ptr_array_index (acfg->globals, i);
sprintf (symbol, "name_%d", i);
emit_pointer (acfg, symbol);
sprintf (symbol2, "%sme_%x", acfg->temp_prefix, i);
- mono_dwarf_writer_emit_method (acfg->dwarf, cfg, cfg->method, cfg->asm_symbol, symbol2, cfg->asm_debug_symbol, cfg->jit_info->code_start, cfg->jit_info->code_size, cfg->args, cfg->locals, cfg->unwind_ops, mono_debug_find_method (cfg->jit_info->d.method, mono_domain_get ()));
+ mono_dwarf_writer_emit_method (acfg->dwarf, cfg, cfg->method, cfg->asm_symbol, symbol2, cfg->asm_debug_symbol, (guint8 *)cfg->jit_info->code_start, cfg->jit_info->code_size, cfg->args, cfg->locals, cfg->unwind_ops, mono_debug_find_method (cfg->jit_info->d.method, mono_domain_get ()));
}
#endif
}
methods = g_new0 (MonoMethod*, methods_len);
//memcpy (methods, g_ptr_array_index (acfg->methods, 0), sizeof (MonoMethod*) * methods_len);
for (i = 0; i < methods_len; ++i)
- methods [i] = g_ptr_array_index (acfg->methods, i);
+ methods [i] = (MonoMethod *)g_ptr_array_index (acfg->methods, i);
i = 0;
while (i < methods_len) {
frag = g_ptr_array_new ();
user_data [1] = acfg;
user_data [2] = frag;
- handle = mono_threads_create_thread ((gpointer)compile_thread_main, user_data, 0, 0, NULL);
+ handle = mono_threads_create_thread ((unsigned int (*)(void *))compile_thread_main, user_data, 0, 0, NULL);
g_ptr_array_add (threads, handle);
}
g_free (methods);
/* Compile methods added by compile_method () or all methods if nthreads == 0 */
for (i = methods_len; i < acfg->methods->len; ++i) {
/* This can new methods to acfg->methods */
- compile_method (acfg, g_ptr_array_index (acfg->methods, i));
+ compile_method (acfg, (MonoMethod *)g_ptr_array_index (acfg->methods, i));
}
}
* during method initialization etc.
*/
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_IMAGE;
ji->data.image = acfg->image;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_MSCORLIB_GOT_ADDR;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_GC_CARD_TABLE_ADDR;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_GC_NURSERY_START;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_JIT_TLS_ID;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_AOT_MODULE;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
ji->type = MONO_PATCH_INFO_GC_NURSERY_BITS;
get_got_offset (acfg, FALSE, ji);
get_got_offset (acfg, TRUE, ji);
for (i = 0; i < sizeof (preinited_jit_icalls) / sizeof (char*); ++i) {
- ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoAotCompile));
+ ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoAotCompile));
ji->type = MONO_PATCH_INFO_INTERNAL_METHOD;
ji->data.name = preinited_jit_icalls [i];
get_got_offset (acfg, FALSE, ji);
aot_printerrf (acfg, "The soft-debug AOT option requires the --debug option.\n");
return 1;
}
- acfg->flags |= MONO_AOT_FILE_FLAG_DEBUG;
+ acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_DEBUG);
}
if (mono_use_llvm || acfg->aot_opts.llvm) {
acfg->llvm = TRUE;
acfg->aot_opts.asm_writer = TRUE;
- acfg->flags |= MONO_AOT_FILE_FLAG_WITH_LLVM;
+ acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_WITH_LLVM);
if (acfg->aot_opts.soft_debug) {
aot_printerrf (acfg, "The 'soft-debug' option is not supported when compiling with LLVM.\n");
}
if (mono_aot_mode_is_full (&acfg->aot_opts))
- acfg->flags |= MONO_AOT_FILE_FLAG_FULL_AOT;
+ acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_FULL_AOT);
if (mono_threads_is_coop_enabled ())
- acfg->flags |= MONO_AOT_FILE_FLAG_SAFEPOINTS;
+ acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_SAFEPOINTS);
if (acfg->aot_opts.instances_logfile_path) {
acfg->instances_logfile = fopen (acfg->aot_opts.instances_logfile_path, "w");
arch_init (acfg);
if (acfg->llvm && acfg->thumb_mixed)
- acfg->flags |= MONO_AOT_FILE_FLAG_LLVM_THUMB;
+ acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_LLVM_THUMB);
if (acfg->aot_opts.llvm_only)
- acfg->flags |= MONO_AOT_FILE_FLAG_LLVM_ONLY;
+ acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_LLVM_ONLY);
acfg->assembly_name_sym = g_strdup (acfg->image->assembly->aname.name);
/* Get rid of characters which cannot occur in symbols */
}
t = g_new0 (MonoType, 1);
- t->type = type;
+ t->type = (MonoTypeEnum)type;
if (is_not_anonymous) {
t->data.generic_param = mono_generic_container_get_param (container, num);
} else {
guint8 *p = buf;
MonoType *t;
- t = g_malloc0 (sizeof (MonoType));
+ t = (MonoType *)g_malloc0 (sizeof (MonoType));
while (TRUE) {
if (*p == MONO_TYPE_PINNED) {
}
}
- t->type = *p;
+ t->type = (MonoTypeEnum)*p;
++p;
switch (t->type) {
array->numsizes = decode_value (p, &p);
if (array->numsizes)
- array->sizes = g_malloc0 (sizeof (int) * array->numsizes);
+ array->sizes = (int *)g_malloc0 (sizeof (int) * array->numsizes);
for (i = 0; i < array->numsizes; ++i)
array->sizes [i] = decode_value (p, &p);
array->numlobounds = decode_value (p, &p);
if (array->numlobounds)
- array->lobounds = g_malloc0 (sizeof (int) * array->numlobounds);
+ array->lobounds = (int *)g_malloc0 (sizeof (int) * array->numlobounds);
for (i = 0; i < array->numlobounds; ++i)
array->lobounds [i] = decode_value (p, &p);
t->data.array = array;
param_count = decode_value (p, &p);
if (target && param_count != target->param_count)
return NULL;
- sig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + param_count * sizeof (MonoType *));
+ sig = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + param_count * sizeof (MonoType *));
sig->param_count = param_count;
sig->sentinelpos = -1;
sig->hasthis = hasthis;
return FALSE;
if (wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE) {
- subtype = decode_value (p, &p);
+ subtype = (WrapperSubtype)decode_value (p, &p);
info = mono_marshal_get_wrapper_info (target);
if (info) {
if (info->subtype != subtype)
#endif
/* The first entry points to the hash */
- table = globals [0];
+ table = (guint16 *)globals [0];
globals ++;
table_size = table [0];
}
build_info = mono_get_runtime_build_info ();
- if (strlen (info->runtime_version) > 0 && strcmp (info->runtime_version, build_info)) {
+ if (strlen ((const char *)info->runtime_version) > 0 && strcmp (info->runtime_version, build_info)) {
msg = g_strdup_printf ("compiled against runtime version '%s' while this runtime has version '%s'", info->runtime_version, build_info);
usable = FALSE;
}
usable = FALSE;
}
- blob = info->blob;
+ blob = (guint8 *)info->blob;
if (info->gc_name_index != -1) {
char *gc_name = (char*)&blob [info->gc_name_index];
amodule->shared_got [i] = amodule->assembly->image;
} else if (ji->type == MONO_PATCH_INFO_MSCORLIB_GOT_ADDR) {
if (mono_defaults.corlib) {
- MonoAotModule *mscorlib_amodule = mono_defaults.corlib->aot_module;
+ MonoAotModule *mscorlib_amodule = (MonoAotModule *)mono_defaults.corlib->aot_module;
if (mscorlib_amodule)
amodule->shared_got [i] = mscorlib_amodule->got;
mono_aot_lock ();
if (static_aot_modules)
- info = g_hash_table_lookup (static_aot_modules, assembly->aname.name);
+ info = (MonoAotFileInfo *)g_hash_table_lookup (static_aot_modules, assembly->aname.name);
else
info = NULL;
mono_aot_unlock ();
/* Statically linked AOT module */
aot_name = g_strdup_printf ("%s", assembly->aname.name);
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "Found statically linked AOT module '%s'.\n", aot_name);
- globals = info->globals;
+ globals = (void **)info->globals;
} else {
if (enable_aot_cache)
sofile = aot_cache_load_module (assembly, &aot_name);
g_assert (info->long_align == align_int64);
g_assert (info->generic_tramp_num == MONO_TRAMPOLINE_NUM);
- blob = info->blob;
+ blob = (guint8 *)info->blob;
amodule = g_new0 (MonoAotModule, 1);
amodule->aot_name = aot_name;
memcpy (&amodule->info, info, sizeof (*info));
- amodule->got = amodule->info.jit_got;
- amodule->llvm_got = amodule->info.llvm_got;
+ amodule->got = (void **)amodule->info.jit_got;
+ amodule->llvm_got = (void **)amodule->info.llvm_got;
amodule->globals = globals;
amodule->sofile = sofile;
amodule->method_to_code = g_hash_table_new (mono_aligned_addr_hash, NULL);
guint32 table_len, i;
char *table = NULL;
- table = info->image_table;
+ table = (char *)info->image_table;
g_assert (table);
table_len = *(guint32*)table;
memcpy (aname->public_key_token, table, strlen (table) + 1);
table += strlen (table) + 1;
- table = ALIGN_PTR_TO (table, 8);
+ table = (char *)ALIGN_PTR_TO (table, 8);
aname->flags = *(guint32*)table;
table += 4;
aname->major = *(guint32*)table;
}
}
- amodule->jit_code_start = info->jit_code_start;
- amodule->jit_code_end = info->jit_code_end;
- amodule->method_info_offsets = info->method_info_offsets;
- amodule->ex_info_offsets = info->ex_info_offsets;
- amodule->class_info_offsets = info->class_info_offsets;
- amodule->class_name_table = info->class_name_table;
- amodule->extra_method_table = info->extra_method_table;
- amodule->extra_method_info_offsets = info->extra_method_info_offsets;
- amodule->unbox_trampolines = info->unbox_trampolines;
- amodule->unbox_trampolines_end = info->unbox_trampolines_end;
- amodule->unbox_trampoline_addresses = info->unbox_trampoline_addresses;
- amodule->unwind_info = info->unwind_info;
+ amodule->jit_code_start = (guint8 *)info->jit_code_start;
+ amodule->jit_code_end = (guint8 *)info->jit_code_end;
+ amodule->method_info_offsets = (guint32 *)info->method_info_offsets;
+ amodule->ex_info_offsets = (guint32 *)info->ex_info_offsets;
+ amodule->class_info_offsets = (guint32 *)info->class_info_offsets;
+ amodule->class_name_table = (guint16 *)info->class_name_table;
+ amodule->extra_method_table = (guint32 *)info->extra_method_table;
+ amodule->extra_method_info_offsets = (guint32 *)info->extra_method_info_offsets;
+ amodule->unbox_trampolines = (guint32 *)info->unbox_trampolines;
+ amodule->unbox_trampolines_end = (guint32 *)info->unbox_trampolines_end;
+ amodule->unbox_trampoline_addresses = (guint32 *)info->unbox_trampoline_addresses;
+ amodule->unwind_info = (guint8 *)info->unwind_info;
amodule->mem_begin = amodule->jit_code_start;
- amodule->mem_end = info->mem_end;
- amodule->plt = info->plt;
- amodule->plt_end = info->plt_end;
- amodule->mono_eh_frame = info->mono_eh_frame;
- amodule->trampolines [MONO_AOT_TRAMP_SPECIFIC] = info->specific_trampolines;
- amodule->trampolines [MONO_AOT_TRAMP_STATIC_RGCTX] = info->static_rgctx_trampolines;
- amodule->trampolines [MONO_AOT_TRAMP_IMT_THUNK] = info->imt_thunks;
- amodule->trampolines [MONO_AOT_TRAMP_GSHAREDVT_ARG] = info->gsharedvt_arg_trampolines;
+ amodule->mem_end = (guint8 *)info->mem_end;
+ amodule->plt = (guint8 *)info->plt;
+ amodule->plt_end = (guint8 *)info->plt_end;
+ amodule->mono_eh_frame = (guint8 *)info->mono_eh_frame;
+ amodule->trampolines [MONO_AOT_TRAMP_SPECIFIC] = (guint8 *)info->specific_trampolines;
+ amodule->trampolines [MONO_AOT_TRAMP_STATIC_RGCTX] = (guint8 *)info->static_rgctx_trampolines;
+ amodule->trampolines [MONO_AOT_TRAMP_IMT_THUNK] = (guint8 *)info->imt_thunks;
+ amodule->trampolines [MONO_AOT_TRAMP_GSHAREDVT_ARG] = (guint8 *)info->gsharedvt_arg_trampolines;
if (!strcmp (assembly->aname.name, "mscorlib"))
mscorlib_aot_module = amodule;
/* Compute method addresses */
- amodule->methods = g_malloc0 (amodule->info.nmethods * sizeof (gpointer));
+ amodule->methods = (void **)g_malloc0 (amodule->info.nmethods * sizeof (gpointer));
for (i = 0; i < amodule->info.nmethods; ++i) {
void *addr = NULL;
if (amodule->info.llvm_get_method) {
- gpointer (*get_method) (int) = amodule->info.llvm_get_method;
+ gpointer (*get_method) (int) = (gpointer (*)(int))amodule->info.llvm_get_method;
addr = get_method (i);
}
{
gpointer *globals;
char *aname;
- MonoAotFileInfo *info = (gpointer)aot_info;
+ MonoAotFileInfo *info = (MonoAotFileInfo *)aot_info;
g_assert (info->version == MONO_AOT_FILE_VERSION);
- globals = info->globals;
+ globals = (void **)info->globals;
g_assert (globals);
- aname = info->assembly_name;
+ aname = (char *)info->assembly_name;
/* This could be called before startup */
if (aot_modules)
{
int i;
MonoClass *klass = vtable->klass;
- MonoAotModule *amodule = klass->image->aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)klass->image->aot_module;
guint8 *info, *p;
MonoCachedClassInfo class_info;
gboolean err;
gboolean
mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res)
{
- MonoAotModule *amodule = klass->image->aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)klass->image->aot_module;
guint8 *p;
gboolean err;
gboolean
mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass)
{
- MonoAotModule *amodule = image->aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)image->aot_module;
guint16 *table, *entry;
guint16 table_size;
guint32 hash;
/* First look in the cache */
if (!amodule->name_cache)
amodule->name_cache = g_hash_table_new (g_str_hash, g_str_equal);
- nspace_table = g_hash_table_lookup (amodule->name_cache, name_space);
+ nspace_table = (GHashTable *)g_hash_table_lookup (amodule->name_cache, name_space);
if (nspace_table) {
- *klass = g_hash_table_lookup (nspace_table, name);
+ *klass = (MonoClass *)g_hash_table_lookup (nspace_table, name);
if (*klass) {
amodule_unlock (amodule);
return TRUE;
/* Add to cache */
if (*klass) {
amodule_lock (amodule);
- nspace_table = g_hash_table_lookup (amodule->name_cache, name_space);
+ nspace_table = (GHashTable *)g_hash_table_lookup (amodule->name_cache, name_space);
if (!nspace_table) {
nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (amodule->name_cache, (char*)name_space2, nspace_table);
gint32 *table;
if (amodule->info.llvm_get_method) {
- gpointer (*get_method) (int) = amodule->info.llvm_get_method;
+ gpointer (*get_method) (int) = (gpointer (*)(int))amodule->info.llvm_get_method;
- *code_start = get_method (-1);
- *code_end = get_method (-2);
+ *code_start = (guint8 *)get_method (-1);
+ *code_end = (guint8 *)get_method (-2);
g_assert (*code_end > *code_start);
return;
g_assert (version == 3);
p ++;
p ++;
- p = ALIGN_PTR_TO (p, 4);
+ p = (guint8 *)ALIGN_PTR_TO (p, 4);
fde_count = *(guint32*)p;
p += 4;
table = (gint32*)p;
if (fde_count > 0) {
- *code_start = amodule->methods [table [0]];
+ *code_start = (guint8 *)amodule->methods [table [0]];
*code_end = (guint8*)amodule->methods [table [(fde_count - 1) * 2]] + table [fde_count * 2];
} else {
*code_start = NULL;
MonoLLVMFDEInfo info;
if (!amodule->mono_eh_frame) {
- jinfo = mono_domain_alloc0_lock_free (domain, mono_jit_info_size (flags, num_clauses, 0));
+ jinfo = (MonoJitInfo *)mono_domain_alloc0_lock_free (domain, mono_jit_info_size (flags, num_clauses, 0));
mono_jit_info_init (jinfo, method, code, code_len, flags, num_clauses, 0);
memcpy (jinfo->clauses, clauses, num_clauses * sizeof (MonoJitExceptionInfo));
return jinfo;
p ++;
/* func_encoding = *p; */
p ++;
- p = ALIGN_PTR_TO (p, 4);
+ p = (guint8 *)ALIGN_PTR_TO (p, 4);
fde_count = *(guint32*)p;
p += 4;
/* The table contains method index/fde offset pairs */
g_assert (table [(pos * 2)] != -1);
- code1 = amodule->methods [table [(pos * 2)]];
+ code1 = (guint8 *)amodule->methods [table [(pos * 2)]];
if (pos + 1 == fde_count) {
code2 = amodule->llvm_code_end;
} else {
g_assert (table [(pos + 1) * 2] != -1);
- code2 = amodule->methods [table [(pos + 1) * 2]];
+ code2 = (guint8 *)amodule->methods [table [(pos + 1) * 2]];
}
if (code < code1)
break;
}
- code_start = amodule->methods [table [(pos * 2)]];
+ code_start = (guint8 *)amodule->methods [table [(pos * 2)]];
if (pos + 1 == fde_count) {
/* The +1 entry in the table contains the length of the last method */
int len = table [(pos + 1) * 2];
code_end = code_start + len;
} else {
- code_end = amodule->methods [table [(pos + 1) * 2]];
+ code_end = (guint8 *)amodule->methods [table [(pos + 1) * 2]];
}
if (!code_len)
code_len = code_end - code_start;
* allocate a new JI.
*/
jinfo =
- mono_domain_alloc0_lock_free (domain, mono_jit_info_size (flags, ei_len + nested_len, 0));
+ (MonoJitInfo *)mono_domain_alloc0_lock_free (domain, mono_jit_info_size (flags, ei_len + nested_len, 0));
mono_jit_info_init (jinfo, method, code, code_len, flags, ei_len + nested_len, 0);
jinfo->unwind_info = mono_cache_unwind_info (info.unw_info, info.unw_info_len);
jei->handler_start = ei [i].handler_start;
jei->clause_index = clause_index;
- if (is_thumb_code (amodule, jei->try_start)) {
+ if (is_thumb_code (amodule, (guint8 *)jei->try_start)) {
jei->try_start = (void*)((mgreg_t)jei->try_start & ~1);
jei->try_end = (void*)((mgreg_t)jei->try_end & ~1);
/* Make sure we transition to thumb when a handler starts */
unwind_info = decode_value (p, &p);
}
if (has_generic_jit_info)
- flags |= JIT_INFO_HAS_GENERIC_JIT_INFO;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_GENERIC_JIT_INFO);
if (has_try_block_holes) {
num_holes = decode_value (p, &p);
- flags |= JIT_INFO_HAS_TRY_BLOCK_HOLES;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_TRY_BLOCK_HOLES);
try_holes_info_size = sizeof (MonoTryBlockHoleTableJitInfo) + num_holes * sizeof (MonoTryBlockHoleJitInfo);
} else {
num_holes = try_holes_info_size = 0;
}
if (has_arch_eh_jit_info) {
- flags |= JIT_INFO_HAS_ARCH_EH_INFO;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_ARCH_EH_INFO);
/* Overwrite the original code_len which includes alignment padding */
code_len = decode_value (p, &p);
}
g_free (nesting);
} else {
len = mono_jit_info_size (flags, num_clauses, num_holes);
- jinfo = alloc0_jit_info_data (domain, len, async);
+ jinfo = (MonoJitInfo *)alloc0_jit_info_data (domain, len, async);
mono_jit_info_init (jinfo, method, code, code_len, flags, num_clauses, num_holes);
for (i = 0; i < jinfo->num_clauses; ++i) {
gi->nlocs = decode_value (p, &p);
if (gi->nlocs) {
- gi->locations = alloc0_jit_info_data (domain, gi->nlocs * sizeof (MonoDwarfLocListEntry), async);
+ gi->locations = (MonoDwarfLocListEntry *)alloc0_jit_info_data (domain, gi->nlocs * sizeof (MonoDwarfLocListEntry), async);
for (i = 0; i < gi->nlocs; ++i) {
MonoDwarfLocListEntry *entry = &gi->locations [i];
{
MonoAotModule *amodule;
guint8 *p;
- guint8 *code = ji->code_start;
+ guint8 *code = (guint8 *)ji->code_start;
if (ji->async)
- amodule = ji->d.aot_info;
+ amodule = (MonoAotModule *)ji->d.aot_info;
else
- amodule = jinfo_get_method (ji)->klass->image->aot_module;
+ amodule = (MonoAotModule *)jinfo_get_method (ji)->klass->image->aot_module;
g_assert (amodule);
g_assert (ji->from_aot);
/* ji belongs to a different aot module than amodule */
mono_aot_lock ();
g_assert (ji_to_amodule);
- amodule = g_hash_table_lookup (ji_to_amodule, ji);
+ amodule = (MonoAotModule *)g_hash_table_lookup (ji_to_amodule, ji);
g_assert (amodule);
g_assert (amodule_contains_code_addr (amodule, code));
mono_aot_unlock ();
int pos, left, right, code_len;
int method_index, table_len;
guint32 token;
- MonoAotModule *amodule = image->aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)image->aot_module;
MonoMethod *method = NULL;
MonoJitInfo *jinfo;
guint8 *code, *ex_info, *p;
/* FIXME: */
return NULL;
- if (!amodule_contains_code_addr (amodule, addr))
+ if (!amodule_contains_code_addr (amodule, (guint8 *)addr))
return NULL;
async = mono_thread_info_is_async_context ();
/* Binary search in the sorted_methods table */
methods = amodule->sorted_methods;
methods_len = amodule->sorted_methods_len;
- code = addr;
+ code = (guint8 *)addr;
left = 0;
right = methods_len;
while (TRUE) {
pos = (left + right) / 2;
- code1 = methods [pos];
+ code1 = (guint8 *)methods [pos];
if (pos + 1 == methods_len) {
if (code1 >= amodule->jit_code_start && code1 < amodule->jit_code_end)
code2 = amodule->jit_code_end;
else
code2 = amodule->llvm_code_end;
} else {
- code2 = methods [pos + 1];
+ code2 = (guint8 *)methods [pos + 1];
}
if (code < code1)
}
}
- code = amodule->methods [method_index];
+ code = (guint8 *)amodule->methods [method_index];
ex_info = &amodule->blob [mono_aot_get_offset (amodule->ex_info_offsets, method_index)];
if (pos == methods_len - 1) {
if (!async) {
if (amodule->extra_methods) {
amodule_lock (amodule);
- method = g_hash_table_lookup (amodule->extra_methods, GUINT_TO_POINTER (method_index));
+ method = (MonoMethod *)g_hash_table_lookup (amodule->extra_methods, GUINT_TO_POINTER (method_index));
amodule_unlock (amodule);
} else {
method = NULL;
len = old_table[0].method_index;
else
len = 1;
- new_table = alloc0_jit_info_data (domain, (len + 1) * sizeof (JitInfoMap), async);
+ new_table = (JitInfoMap *)alloc0_jit_info_data (domain, (len + 1) * sizeof (JitInfoMap), async);
if (old_table)
memcpy (new_table, old_table, len * sizeof (JitInfoMap));
new_table [0].method_index = len + 1;
new_table [len].jinfo = jinfo;
/* Publish it */
mono_memory_barrier ();
- if (InterlockedCompareExchangePointer ((gpointer)&amodule->async_jit_info_table, new_table, old_table) == old_table)
+ if (InterlockedCompareExchangePointer ((volatile gpointer *)&amodule->async_jit_info_table, new_table, old_table) == old_table)
break;
}
} else {
goto cleanup;
break;
case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE:
- ji->data.del_tramp = mono_mempool_alloc0 (mp, sizeof (MonoDelegateClassMethodPair));
+ ji->data.del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (mp, sizeof (MonoDelegateClassMethodPair));
ji->data.del_tramp->klass = decode_klass_ref (aot_module, p, &p);
if (!ji->data.del_tramp->klass)
goto cleanup;
goto cleanup;
break;
case MONO_PATCH_INFO_SWITCH:
- ji->data.table = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoBBTable));
+ ji->data.table = (MonoJumpInfoBBTable *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoBBTable));
ji->data.table->table_size = decode_value (p, &p);
- table = mono_domain_alloc (mono_domain_get (), sizeof (gpointer) * ji->data.table->table_size);
+ table = (void **)mono_domain_alloc (mono_domain_get (), sizeof (gpointer) * ji->data.table->table_size);
ji->data.table->table = (MonoBasicBlock**)table;
for (i = 0; i < ji->data.table->table_size; i++)
table [i] = (gpointer)(gssize)decode_value (p, &p);
offset = decode_value (p, &p);
val = decode_value (p, &p);
- entry = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
+ entry = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
p2 = aot_module->blob + offset;
entry->method = decode_resolve_method_ref (aot_module, p2, &p2);
entry->in_mrgctx = ((val & 1) > 0) ? TRUE : FALSE;
- entry->info_type = (val >> 1) & 0xff;
- entry->data = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
- entry->data->type = (val >> 9) & 0xff;
+ entry->info_type = (MonoRgctxInfoType)((val >> 1) & 0xff);
+ entry->data = (MonoJumpInfo *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
+ entry->data->type = (MonoJumpInfoType)((val >> 9) & 0xff);
res = decode_patch (aot_module, mp, entry->data, p, &p);
if (!res)
ji->data.target = GINT_TO_POINTER (decode_value (p, &p));
break;
case MONO_PATCH_INFO_GSHAREDVT_CALL: {
- MonoJumpInfoGSharedVtCall *info = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoGSharedVtCall));
+ MonoJumpInfoGSharedVtCall *info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoGSharedVtCall));
info->sig = decode_signature (aot_module, p, &p);
g_assert (info->sig);
info->method = decode_resolve_method_ref (aot_module, p, &p);
break;
}
case MONO_PATCH_INFO_GSHAREDVT_METHOD: {
- MonoGSharedVtMethodInfo *info = mono_mempool_alloc0 (mp, sizeof (MonoGSharedVtMethodInfo));
+ MonoGSharedVtMethodInfo *info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (mp, sizeof (MonoGSharedVtMethodInfo));
int i;
info->method = decode_resolve_method_ref (aot_module, p, &p);
g_assert (info->method);
info->num_entries = decode_value (p, &p);
info->count_entries = info->num_entries;
- info->entries = mono_mempool_alloc0 (mp, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->num_entries);
+ info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (mp, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->num_entries);
for (i = 0; i < info->num_entries; ++i) {
- MonoRuntimeGenericContextInfoTemplate *template = &info->entries [i];
+ MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
- template->info_type = decode_value (p, &p);
- switch (mini_rgctx_info_type_to_patch_info_type (template->info_type)) {
+ template_->info_type = (MonoRgctxInfoType)decode_value (p, &p);
+ switch (mini_rgctx_info_type_to_patch_info_type (template_->info_type)) {
case MONO_PATCH_INFO_CLASS: {
MonoClass *klass = decode_klass_ref (aot_module, p, &p);
if (!klass)
goto cleanup;
- template->data = &klass->byval_arg;
+ template_->data = &klass->byval_arg;
break;
}
case MONO_PATCH_INFO_FIELD:
- template->data = decode_field_info (aot_module, p, &p);
- if (!template->data)
+ template_->data = decode_field_info (aot_module, p, &p);
+ if (!template_->data)
goto cleanup;
break;
default:
int len = decode_value (p, &p);
char *s;
- s = mono_mempool_alloc0 (mp, len + 1);
+ s = (char *)mono_mempool_alloc0 (mp, len + 1);
memcpy (s, p, len + 1);
p += len + 1;
break;
}
case MONO_PATCH_INFO_VIRT_METHOD: {
- MonoJumpInfoVirtMethod *info = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoVirtMethod));
+ MonoJumpInfoVirtMethod *info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoVirtMethod));
info->klass = decode_klass_ref (aot_module, p, &p);
g_assert (info->klass);
if (llvm) {
got = amodule->llvm_got;
- got_info_offsets = amodule->info.llvm_got_info_offsets;
+ got_info_offsets = (guint32 *)amodule->info.llvm_got_info_offsets;
} else {
got = amodule->got;
- got_info_offsets = amodule->info.got_info_offsets;
+ got_info_offsets = (guint32 *)amodule->info.got_info_offsets;
}
- patches = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo) * n_patches);
+ patches = (MonoJumpInfo *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo) * n_patches);
for (i = 0; i < n_patches; ++i) {
guint8 *p = amodule->blob + mono_aot_get_offset (got_info_offsets, got_offsets [i]);
ji = &patches [i];
- ji->type = decode_value (p, &p);
+ ji->type = (MonoJumpInfoType)decode_value (p, &p);
/* See load_method () for SFLDA */
if (got && got [got_offsets [i]] && ji->type != MONO_PATCH_INFO_SFLDA) {
p = buf;
- *got_slots = g_malloc (sizeof (guint32) * n_patches);
+ *got_slots = (guint32 *)g_malloc (sizeof (guint32) * n_patches);
for (pindex = 0; pindex < n_patches; ++pindex) {
(*got_slots)[pindex] = decode_value (p, &p);
}
mono_domain_lock (domain);
if (!info->jump_target_got_slot_hash)
info->jump_target_got_slot_hash = g_hash_table_new (NULL, NULL);
- list = g_hash_table_lookup (info->jump_target_got_slot_hash, method);
+ list = (GSList *)g_hash_table_lookup (info->jump_target_got_slot_hash, method);
list = g_slist_prepend (list, got_slot);
g_hash_table_insert (info->jump_target_got_slot_hash, method, list);
mono_domain_unlock (domain);
/*
* Obtain the method address by calling a generated function in the LLVM module.
*/
- gpointer (*get_method) (int) = amodule->info.llvm_get_method;
- code = get_method (method_index);
+ gpointer (*get_method) (int) = (gpointer (*)(int))amodule->info.llvm_get_method;
+ code = (guint8 *)get_method (method_index);
}
if (!code) {
}
return NULL;
}
- code = amodule->methods [method_index];
+ code = (guint8 *)amodule->methods [method_index];
}
info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
amodule_lock (amodule);
if (!amodule->method_ref_to_method)
amodule->method_ref_to_method = g_hash_table_new (NULL, NULL);
- m = g_hash_table_lookup (amodule->method_ref_to_method, p);
+ m = (MonoMethod *)g_hash_table_lookup (amodule->method_ref_to_method, p);
amodule_unlock (amodule);
if (!m) {
m = decode_resolve_method_ref_with_target (amodule, method, p, &p);
guint32 hash = mono_aot_method_hash (method);
/* Try the method's module first */
- *out_amodule = method->klass->image->aot_module;
- index = find_aot_method_in_amodule (method->klass->image->aot_module, method, hash);
+ *out_amodule = (MonoAotModule *)method->klass->image->aot_module;
+ index = find_aot_method_in_amodule ((MonoAotModule *)method->klass->image->aot_module, method, hash);
if (index != 0xffffff)
return index;
index = 0xffffff;
for (i = 0; i < modules->len; ++i) {
- MonoAotModule *amodule = g_ptr_array_index (modules, i);
+ MonoAotModule *amodule = (MonoAotModule *)g_ptr_array_index (modules, i);
if (amodule != method->klass->image->aot_module)
index = find_aot_method_in_amodule (amodule, method, hash);
MonoJitInfo *jinfo = NULL;
guint8 *code, *info;
- code = amodule->methods [method_index];
+ code = (guint8 *)amodule->methods [method_index];
info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
p = info;
void
mono_aot_init_llvm_method (gpointer aot_module, guint32 method_index)
{
- MonoAotModule *amodule = aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)aot_module;
gboolean res;
// FIXME: Handle failure
}
void
-mono_aot_init_gshared_method_this (gpointer aot_module, guint32 method_index, MonoObject *this)
+mono_aot_init_gshared_method_this (gpointer aot_module, guint32 method_index, MonoObject *this_obj)
{
- MonoAotModule *amodule = aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)aot_module;
gboolean res;
MonoClass *klass;
MonoGenericContext *context;
MonoMethod *method;
// FIXME:
- g_assert (this);
- klass = this->vtable->klass;
+ g_assert (this_obj);
+ klass = this_obj->vtable->klass;
amodule_lock (amodule);
- method = g_hash_table_lookup (amodule->extra_methods, GUINT_TO_POINTER (method_index));
+ method = (MonoMethod *)g_hash_table_lookup (amodule->extra_methods, GUINT_TO_POINTER (method_index));
amodule_unlock (amodule);
g_assert (method);
void
mono_aot_init_gshared_method_rgctx (gpointer aot_module, guint32 method_index, MonoMethodRuntimeGenericContext *rgctx)
{
- MonoAotModule *amodule = aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)aot_module;
gboolean res;
MonoGenericContext context = { NULL, NULL };
MonoClass *klass = rgctx->class_vtable->klass;
MonoClass *klass = method->klass;
MonoMethod *orig_method = method;
guint32 method_index;
- MonoAotModule *amodule = klass->image->aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)klass->image->aot_module;
guint8 *code;
gboolean cache_result = FALSE;
if (!mscorlib_aot_loaded) {
mscorlib_aot_loaded = TRUE;
load_aot_module (klass->image->assembly, NULL);
- amodule = klass->image->aot_module;
+ amodule = (MonoAotModule *)klass->image->aot_module;
}
}
} else if (method->is_inflated || !method->token) {
/* This hash table is used to avoid the slower search in the extra_method_table in the AOT image */
amodule_lock (amodule);
- code = g_hash_table_lookup (amodule->method_to_code, method);
+ code = (guint8 *)g_hash_table_lookup (amodule->method_to_code, method);
amodule_unlock (amodule);
if (code)
return code;
if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED && method->klass->rank && strstr (method->name, "System.Collections.Generic")) {
MonoMethod *m = mono_aot_get_array_helper_from_wrapper (method);
- code = mono_aot_get_method (domain, m);
+ code = (guint8 *)mono_aot_get_method (domain, m);
if (code)
return code;
}
* Get the code for the <object> instantiation which should be emitted into
* the mscorlib aot image by the AOT compiler.
*/
- code = mono_aot_get_method (domain, m);
+ code = (guint8 *)mono_aot_get_method (domain, m);
if (code)
return code;
}
* Get the code for the <object> instantiation which should be emitted into
* the mscorlib aot image by the AOT compiler.
*/
- code = mono_aot_get_method (domain, m);
+ code = (guint8 *)mono_aot_get_method (domain, m);
if (code)
return code;
}
m = mono_marshal_get_array_accessor_wrapper (m);
if (m != method) {
- code = mono_aot_get_method (domain, m);
+ code = (guint8 *)mono_aot_get_method (domain, m);
if (code)
return code;
}
method_index = mono_metadata_token_index (method->token) - 1;
}
- code = load_method (domain, amodule, klass->image, method, method->token, method_index);
+ code = (guint8 *)load_method (domain, amodule, klass->image, method, method->token, method_index);
if (code && cache_result) {
amodule_lock (amodule);
g_hash_table_insert (amodule->method_to_code, orig_method, code);
gpointer
mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token)
{
- MonoAotModule *aot_module = image->aot_module;
+ MonoAotModule *aot_module = (MonoAotModule *)image->aot_module;
int method_index;
if (!aot_module)
p = &module->blob [plt_info_offset];
- ji.type = decode_value (p, &p);
+ ji.type = (MonoJumpInfoType)decode_value (p, &p);
mp = mono_mempool_new ();
res = decode_patch (module, mp, &ji, p, &p);
*/
if (mono_aot_only && ji.type == MONO_PATCH_INFO_METHOD && !ji.data.method->is_generic && !mono_method_check_context_used (ji.data.method) && !(ji.data.method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) &&
!mono_method_needs_static_rgctx_invoke (ji.data.method, FALSE) && !using_gsharedvt) {
- target = mono_jit_compile_method (ji.data.method);
+ target = (guint8 *)mono_jit_compile_method (ji.data.method);
no_ftnptr = TRUE;
} else {
- target = mono_resolve_patch_target (NULL, mono_domain_get (), NULL, &ji, TRUE);
+ target = (guint8 *)mono_resolve_patch_target (NULL, mono_domain_get (), NULL, &ji, TRUE);
}
/*
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
g_assert (((gpointer*)target) [2] != 0);
#endif
- target = mono_create_ftnptr (mono_domain_get (), target);
+ target = (guint8 *)mono_create_ftnptr (mono_domain_get (), target);
}
mono_mempool_destroy (mp);
uw_info_len = decode_value (uw_info, &uw_info);
tinfo = g_new0 (MonoTrampInfo, 1);
- tinfo->code = code;
+ tinfo->code = (guint8 *)code;
tinfo->code_size = code_size;
tinfo->uw_info = uw_info;
tinfo->uw_info_len = uw_info_len;
} else if (!strcmp (ji->data.name, "mono_throw_exception")) {
target = mono_get_throw_exception ();
} else if (strstr (ji->data.name, "trampoline_func_") == ji->data.name) {
- int tramp_type2 = atoi (ji->data.name + strlen ("trampoline_func_"));
+ MonoTrampolineType tramp_type2 = (MonoTrampolineType)atoi (ji->data.name + strlen ("trampoline_func_"));
target = (gpointer)mono_get_trampoline_func (tramp_type2);
} else if (strstr (ji->data.name, "specific_trampoline_lazy_fetch_") == ji->data.name) {
/* atoll is needed because the the offset is unsigned */
res = sscanf (ji->data.name, "specific_trampoline_lazy_fetch_%u", &slot);
g_assert (res == 1);
target = mono_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
- target = mono_create_ftnptr_malloc (target);
+ target = mono_create_ftnptr_malloc ((guint8 *)target);
} else if (!strcmp (ji->data.name, "mono_thread_get_and_clear_pending_exception")) {
target = mono_thread_get_and_clear_pending_exception;
} else if (!strcmp (ji->data.name, "debugger_agent_single_step_from_context")) {
/* Hopefully the code doesn't have patches which need method or
* domain to be set.
*/
- target = mono_resolve_patch_target (NULL, NULL, code, ji, FALSE);
+ target = mono_resolve_patch_target (NULL, NULL, (guint8 *)code, ji, FALSE);
g_assert (target);
}
image = mono_defaults.corlib;
if (image)
- amodule = image->aot_module;
+ amodule = (MonoAotModule *)image->aot_module;
else
amodule = mscorlib_aot_module;
g_assert (amodule);
return no_trampolines;
}
- return mono_create_ftnptr_malloc (load_function_full (amodule, name, out_tinfo));
+ return mono_create_ftnptr_malloc ((guint8 *)load_function_full (amodule, name, out_tinfo));
}
gpointer
g_free (symbol);
}
- tramp = generic_trampolines [tramp_type];
+ tramp = (guint8 *)generic_trampolines [tramp_type];
g_assert (tramp);
if (USE_PAGE_TRAMPOLINES) {
- code = get_new_specific_trampoline_from_page (tramp, arg1);
+ code = (guint8 *)get_new_specific_trampoline_from_page (tramp, arg1);
tramp_size = 8;
} else {
- code = get_numerous_trampoline (MONO_AOT_TRAMP_SPECIFIC, 2, &amodule, &got_offset, &tramp_size);
+ code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_SPECIFIC, 2, &amodule, &got_offset, &tramp_size);
amodule->got [got_offset] = tramp;
amodule->got [got_offset + 1] = arg1;
guint32 got_offset;
if (USE_PAGE_TRAMPOLINES) {
- code = get_new_rgctx_trampoline_from_page (addr, ctx);
+ code = (guint8 *)get_new_rgctx_trampoline_from_page (addr, ctx);
} else {
- code = get_numerous_trampoline (MONO_AOT_TRAMP_STATIC_RGCTX, 2, &amodule, &got_offset, NULL);
+ code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_STATIC_RGCTX, 2, &amodule, &got_offset, NULL);
amodule->got [got_offset] = ctx;
amodule->got [got_offset + 1] = addr;
}
g_assert (method_index != 0xffffff);
} else {
- amodule = method->klass->image->aot_module;
+ amodule = (MonoAotModule *)method->klass->image->aot_module;
g_assert (amodule);
}
if (amodule->info.llvm_get_unbox_tramp) {
- gpointer (*get_tramp) (int) = amodule->info.llvm_get_unbox_tramp;
+ gpointer (*get_tramp) (int) = (gpointer (*)(int))amodule->info.llvm_get_unbox_tramp;
code = get_tramp (method_index);
if (code)
code = get_call_table_entry (amodule->unbox_trampoline_addresses, entry_index);
g_assert (code);
- tinfo = mono_tramp_info_create (NULL, code, 0, NULL, NULL);
+ tinfo = mono_tramp_info_create (NULL, (guint8 *)code, 0, NULL, NULL);
symbol_addr = read_unwind_info (amodule, tinfo, "unbox_trampoline_p");
if (!symbol_addr) {
{
char *symbol;
gpointer code;
- MonoAotModule *amodule = mono_defaults.corlib->aot_module;
+ MonoAotModule *amodule = (MonoAotModule *)mono_defaults.corlib->aot_module;
guint32 index = MONO_RGCTX_SLOT_INDEX (slot);
static int count = 0;
*/
if (!addr)
addr = load_function (amodule, "rgctx_fetch_trampoline_general");
- info = mono_domain_alloc0 (mono_get_root_domain (), sizeof (gpointer) * 2);
+ info = (void **)mono_domain_alloc0 (mono_get_root_domain (), sizeof (gpointer) * 2);
info [0] = GUINT_TO_POINTER (slot);
info [1] = mono_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
code = mono_aot_get_static_rgctx_trampoline (info, addr);
}
symbol = mono_get_rgctx_fetch_trampoline_name (slot);
- code = load_function (mono_defaults.corlib->aot_module, symbol);
+ code = load_function ((MonoAotModule *)mono_defaults.corlib->aot_module, symbol);
g_free (symbol);
/* The caller expects an ftnptr */
return mono_create_ftnptr (mono_domain_get (), code);
}
/* Save the entries into an array */
- buf = mono_domain_alloc (domain, (real_count + 1) * 2 * sizeof (gpointer));
+ buf = (void **)mono_domain_alloc (domain, (real_count + 1) * 2 * sizeof (gpointer));
index = 0;
for (i = 0; i < count; ++i) {
MonoIMTCheckItem *item = imt_entries [i];
buf [(index * 2)] = item->key;
if (item->has_target_code) {
- gpointer *p = mono_domain_alloc (domain, sizeof (gpointer));
+ gpointer *p = (gpointer *)mono_domain_alloc (domain, sizeof (gpointer));
*p = item->value.target_code;
buf [(index * 2) + 1] = p;
} else {
guint32 got_offset;
if (USE_PAGE_TRAMPOLINES) {
- code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
+ code = (guint8 *)get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
} else {
- code = get_numerous_trampoline (MONO_AOT_TRAMP_GSHAREDVT_ARG, 2, &amodule, &got_offset, NULL);
+ code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_GSHAREDVT_ARG, 2, &amodule, &got_offset, NULL);
amodule->got [got_offset] = arg;
amodule->got [got_offset + 1] = addr;
MONO_INST_NEW (cfg, jump, OP_BR);
/* Allocate memory for our branch target */
- jump->inst_i1 = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
+ jump->inst_i1 = (MonoInst *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
jump->inst_true_bb = targetbb;
if (cfg->verbose_level > 2)
ins->inst_false_bb = repl;
} else if (MONO_IS_JUMP_TABLE (ins)) {
int i;
- MonoJumpInfoBBTable *table = MONO_JUMP_TABLE_FROM_INS (ins);
+ MonoJumpInfoBBTable *table = (MonoJumpInfoBBTable *)MONO_JUMP_TABLE_FROM_INS (ins);
for (i = 0; i < table->table_size; i++ ) {
if (table->table [i] == orig)
table->table [i] = repl;
for (inst = bb->code; inst != NULL; inst = inst->next) {
if (MONO_IS_JUMP_TABLE (inst)) {
int i;
- MonoJumpInfoBBTable *table = MONO_JUMP_TABLE_FROM_INS (inst);
+ MonoJumpInfoBBTable *table = (MonoJumpInfoBBTable *)MONO_JUMP_TABLE_FROM_INS (inst);
for (i = 0; i < table->table_size; i++ ) {
/* Might be already NULL from a previous merge */
if (table->table [i])
* overwrite the sreg1 of the ins.
*/
if ((in_bb->out_count > 1) || (in_bb->out_count == 1 && in_bb->last_ins && in_bb->last_ins->opcode == OP_BR_REG)) {
- MonoBasicBlock *new_bb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
+ MonoBasicBlock *new_bb = (MonoBasicBlock *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
new_bb->block_num = cfg->num_bblocks++;
// new_bb->real_offset = bb->real_offset;
new_bb->region = bb->region;
/* We cannot add any inst to the entry BB, so we must */
/* put a new BB in the middle to hold the OP_BR */
MonoInst *jump;
- MonoBasicBlock *new_bb_after_entry = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
+ MonoBasicBlock *new_bb_after_entry = (MonoBasicBlock *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
new_bb_after_entry->block_num = cfg->num_bblocks++;
// new_bb_after_entry->real_offset = bb->real_offset;
new_bb_after_entry->region = bb->region;
previous_bb = new_bb;
/* Setup in_bb and out_bb */
- new_bb->in_bb = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoBasicBlock*));
+ new_bb->in_bb = (MonoBasicBlock **)mono_mempool_alloc ((cfg)->mempool, sizeof (MonoBasicBlock*));
new_bb->in_bb [0] = in_bb;
new_bb->in_count = 1;
- new_bb->out_bb = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoBasicBlock*));
+ new_bb->out_bb = (MonoBasicBlock **)mono_mempool_alloc ((cfg)->mempool, sizeof (MonoBasicBlock*));
new_bb->out_bb [0] = bb;
new_bb->out_count = 1;
}
size = ((jit->num_params + jit->num_locals + 1) * 10) + (jit->num_line_numbers * 10) + 64;
- p = buf = g_malloc (size);
+ p = buf = (guint8 *)g_malloc (size);
encode_value (jit->epilogue_begin, p, &p);
encode_value (jit->prologue_end, p, &p);
encode_value (jit->code_size, p, &p);
mono_debug_print_vars (gpointer ip, gboolean only_arguments)
{
MonoDomain *domain = mono_domain_get ();
- MonoJitInfo *ji = mono_jit_info_table_find (domain, ip);
+ MonoJitInfo *ji = mono_jit_info_table_find (domain, (char *)ip);
MonoDebugMethodJitInfo *jit;
int i;
return 0;
for (i = 0; i < breakpoints->len; i++) {
- MiniDebugBreakpointInfo *info = g_ptr_array_index (breakpoints, i);
+ MiniDebugBreakpointInfo *info = (MiniDebugBreakpointInfo *)g_ptr_array_index (breakpoints, i);
if (!mono_method_desc_full_match (info->desc, method))
continue;
if (pos == NULL || pos == address)
return 1;
- *host = g_malloc (pos - address + 1);
+ *host = (char *)g_malloc (pos - address + 1);
strncpy (*host, address, pos - address);
(*host) [pos - address] = '\0';
mono_coop_cond_init (&debugger_thread_exited_cond);
mono_profiler_install ((MonoProfiler*)&debugger_profiler, runtime_shutdown);
- mono_profiler_set_events (MONO_PROFILE_APPDOMAIN_EVENTS | MONO_PROFILE_THREADS | MONO_PROFILE_ASSEMBLY_EVENTS | MONO_PROFILE_JIT_COMPILATION | MONO_PROFILE_METHOD_EVENTS);
+ mono_profiler_set_events ((MonoProfileFlags)(MONO_PROFILE_APPDOMAIN_EVENTS | MONO_PROFILE_THREADS | MONO_PROFILE_ASSEMBLY_EVENTS | MONO_PROFILE_JIT_COMPILATION | MONO_PROFILE_METHOD_EVENTS));
mono_profiler_install_runtime_initialized (runtime_initialized);
mono_profiler_install_appdomain (NULL, appdomain_load, appdomain_start_unload, appdomain_unload);
mono_profiler_install_thread (thread_startup, thread_end);
argv [2] = agent_config.address;
argv [3] = NULL;
- res = g_spawn_async_with_pipes (NULL, argv, NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+ res = g_spawn_async_with_pipes (NULL, argv, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
if (!res) {
fprintf (stderr, "Failed to execute '%s'.\n", agent_config.launch);
exit (1);
return NULL;
}
- s = g_malloc (len + 1);
+ s = (char *)g_malloc (len + 1);
g_assert (s);
memcpy (s, buf, len);
static inline void
buffer_init (Buffer *buf, int size)
{
- buf->buf = g_malloc (size);
+ buf->buf = (guint8 *)g_malloc (size);
buf->p = buf->buf;
buf->end = buf->buf + size;
}
{
if (buf->end - buf->p < size) {
int new_size = buf->end - buf->buf + size + 32;
- guint8 *p = g_realloc (buf->buf, new_size);
+ guint8 *p = (guint8 *)g_realloc (buf->buf, new_size);
size = buf->p - buf->buf;
buf->buf = p;
buf->p = p + size;
static void
free_objref (gpointer value)
{
- ObjRef *o = value;
+ ObjRef *o = (ObjRef *)value;
mono_gchandle_free (o->handle);
*/
hash = mono_object_hash (obj);
- reflist = g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (hash));
+ reflist = (GSList *)g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (hash));
for (l = reflist; l; l = l->next) {
- ref = l->data;
+ ref = (ObjRef *)l->data;
if (ref && mono_gchandle_get_target (ref->handle) == obj) {
mono_loader_unlock ();
return ref;
}
} else {
/* Use a hash table with masked pointers to internalize object references */
- ref = g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)));
+ ref = (ObjRef *)g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)));
/* ref might refer to a different object with the same addr which was GCd */
if (ref && mono_gchandle_get_target (ref->handle) == obj) {
mono_loader_unlock ();
if (objid == 0) {
*obj = NULL;
- return 0;
+ return ERR_NONE;
}
if (!objrefs)
mono_loader_lock ();
- ref = g_hash_table_lookup (objrefs, GINT_TO_POINTER (objid));
+ ref = (ObjRef *)g_hash_table_lookup (objrefs, GINT_TO_POINTER (objid));
if (ref) {
*obj = mono_gchandle_get_target (ref->handle);
mono_loader_unlock ();
if (!(*obj))
return ERR_INVALID_OBJECT;
- return 0;
+ return ERR_NONE;
} else {
mono_loader_unlock ();
return ERR_INVALID_OBJECT;
static ErrorCode
get_object (int objid, MonoObject **obj)
{
- int err = get_object_allow_null (objid, obj);
+ ErrorCode err = get_object_allow_null (objid, obj);
- if (err)
+ if (err != ERR_NONE)
return err;
if (!(*obj))
return ERR_INVALID_OBJECT;
- return 0;
+ return ERR_NONE;
}
static inline int
void
mono_debugger_agent_free_domain_info (MonoDomain *domain)
{
- AgentDomainInfo *info = domain_jit_info (domain)->agent_info;
+ AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
int i, j;
GHashTableIter iter;
GPtrArray *file_names;
for (i = 0; i < ID_NUM; ++i) {
if (ids [i]) {
for (j = 0; j < ids [i]->len; ++j) {
- Id *id = g_ptr_array_index (ids [i], j);
+ Id *id = (Id *)g_ptr_array_index (ids [i], j);
if (id->domain == domain)
id->domain = NULL;
}
mono_domain_lock (domain);
- info = domain_jit_info (domain)->agent_info;
+ info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
if (!info) {
- info = domain_jit_info (domain)->agent_info = g_new0 (AgentDomainInfo, 1);
+ info = g_new0 (AgentDomainInfo, 1);
+ domain_jit_info (domain)->agent_info = info;
info->loaded_classes = g_hash_table_new (mono_aligned_addr_hash, NULL);
info->source_files = g_hash_table_new (mono_aligned_addr_hash, NULL);
info->source_file_to_class = g_hash_table_new (g_str_hash, g_str_equal);
if (info->val_to_id [type] == NULL)
info->val_to_id [type] = g_hash_table_new (mono_aligned_addr_hash, NULL);
- id = g_hash_table_lookup (info->val_to_id [type], val);
+ id = (Id *)g_hash_table_lookup (info->val_to_id [type], val);
if (id) {
dbg_unlock ();
return id->id;
}
static inline gpointer
-decode_ptr_id (guint8 *buf, guint8 **endbuf, guint8 *limit, IdType type, MonoDomain **domain, int *err)
+decode_ptr_id (guint8 *buf, guint8 **endbuf, guint8 *limit, IdType type, MonoDomain **domain, ErrorCode *err)
{
Id *res;
int id = decode_id (buf, endbuf, limit);
- *err = 0;
+ *err = ERR_NONE;
if (domain)
*domain = NULL;
dbg_lock ();
g_assert (id > 0 && id <= ids [type]->len);
- res = g_ptr_array_index (ids [type], GPOINTER_TO_INT (id - 1));
+ res = (Id *)g_ptr_array_index (ids [type], GPOINTER_TO_INT (id - 1));
dbg_unlock ();
if (res->domain == NULL) {
}
static inline MonoClass*
-decode_typeid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_typeid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
MonoClass *klass;
- klass = decode_ptr_id (buf, endbuf, limit, ID_TYPE, domain, err);
+ klass = (MonoClass *)decode_ptr_id (buf, endbuf, limit, ID_TYPE, domain, err);
if (G_UNLIKELY (log_level >= 2) && klass) {
char *s;
}
static inline MonoAssembly*
-decode_assemblyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_assemblyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
- return decode_ptr_id (buf, endbuf, limit, ID_ASSEMBLY, domain, err);
+ return (MonoAssembly *)decode_ptr_id (buf, endbuf, limit, ID_ASSEMBLY, domain, err);
}
static inline MonoImage*
-decode_moduleid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_moduleid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
- return decode_ptr_id (buf, endbuf, limit, ID_MODULE, domain, err);
+ return (MonoImage *)decode_ptr_id (buf, endbuf, limit, ID_MODULE, domain, err);
}
static inline MonoMethod*
-decode_methodid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_methodid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
MonoMethod *m;
- m = decode_ptr_id (buf, endbuf, limit, ID_METHOD, domain, err);
+ m = (MonoMethod *)decode_ptr_id (buf, endbuf, limit, ID_METHOD, domain, err);
if (G_UNLIKELY (log_level >= 2) && m) {
char *s;
}
static inline MonoClassField*
-decode_fieldid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_fieldid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
- return decode_ptr_id (buf, endbuf, limit, ID_FIELD, domain, err);
+ return (MonoClassField *)decode_ptr_id (buf, endbuf, limit, ID_FIELD, domain, err);
}
static inline MonoDomain*
-decode_domainid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_domainid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
- return decode_ptr_id (buf, endbuf, limit, ID_DOMAIN, domain, err);
+ return (MonoDomain *)decode_ptr_id (buf, endbuf, limit, ID_DOMAIN, domain, err);
}
static inline MonoProperty*
-decode_propertyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
+decode_propertyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
{
- return decode_ptr_id (buf, endbuf, limit, ID_PROPERTY, domain, err);
+ return (MonoProperty *)decode_ptr_id (buf, endbuf, limit, ID_PROPERTY, domain, err);
}
static inline void
{
DebuggerTlsData *tls;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
if (ctx)
static gboolean
get_last_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
{
- GetLastFrameUserData *data = user_data;
+ GetLastFrameUserData *data = (GetLastFrameUserData *)user_data;
if (info->type == FRAME_TYPE_MANAGED_TO_NATIVE || info->type == FRAME_TYPE_TRAMPOLINE)
return FALSE;
static void
reset_native_thread_suspend_state (gpointer key, gpointer value, gpointer user_data)
{
- DebuggerTlsData *tls = value;
+ DebuggerTlsData *tls = (DebuggerTlsData *)value;
if (!tls->really_suspended && tls->suspended) {
tls->suspended = FALSE;
static SuspendThreadResult
debugger_interrupt_critical (MonoThreadInfo *info, gpointer user_data)
{
- InterruptData *data = user_data;
+ InterruptData *data = (InterruptData *)user_data;
MonoJitInfo *ji;
data->valid_info = TRUE;
ji = mono_jit_info_table_find_internal (
- mono_thread_info_get_suspend_state (info)->unwind_data [MONO_UNWIND_DATA_DOMAIN],
- MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx),
+ (MonoDomain *)mono_thread_info_get_suspend_state (info)->unwind_data [MONO_UNWIND_DATA_DOMAIN],
+ (char *)MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx),
TRUE,
TRUE);
static void
notify_thread (gpointer key, gpointer value, gpointer user_data)
{
- MonoInternalThread *thread = key;
- DebuggerTlsData *tls = value;
+ MonoInternalThread *thread = (MonoInternalThread *)key;
+ DebuggerTlsData *tls = (DebuggerTlsData *)value;
MonoNativeThreadId tid = MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid);
if (mono_native_thread_id_equals (mono_native_thread_id_get (), tid) || tls->terminated)
static void
process_suspend (DebuggerTlsData *tls, MonoContext *ctx)
{
- guint8 *ip = MONO_CONTEXT_GET_IP (ctx);
+ guint8 *ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
MonoJitInfo *ji;
MonoMethod *method;
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
g_assert (tls);
mono_coop_mutex_lock (&suspend_mutex);
invalidate_frames (DebuggerTlsData *tls)
{
if (!tls)
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
free_frames (tls->frames, tls->frame_count);
return;
}
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
mono_coop_mutex_lock (&suspend_mutex);
static void
count_thread (gpointer key, gpointer value, gpointer user_data)
{
- DebuggerTlsData *tls = value;
+ DebuggerTlsData *tls = (DebuggerTlsData *)value;
if (!tls->suspended && !tls->terminated)
*(int*)user_data = *(int*)user_data + 1;
static gboolean
process_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
{
- ComputeFramesUserData *ud = user_data;
+ ComputeFramesUserData *ud = (ComputeFramesUserData *)user_data;
StackFrame *frame;
MonoMethod *method, *actual_method, *api_method;
SeqPoint sp;
static gboolean
process_filter_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
{
- ComputeFramesUserData *ud = user_data;
+ ComputeFramesUserData *ud = (ComputeFramesUserData *)user_data;
/*
* 'tls->filter_ctx' is the location of the throw site.
compute_frame_info_from (MonoInternalThread *thread, DebuggerTlsData *tls, MonoThreadUnwindState *state, int *out_nframes)
{
ComputeFramesUserData user_data;
- MonoUnwindOptions opts = MONO_UNWIND_DEFAULT|MONO_UNWIND_REG_LOCATIONS;
+ MonoUnwindOptions opts = (MonoUnwindOptions)(MONO_UNWIND_DEFAULT | MONO_UNWIND_REG_LOCATIONS);
StackFrame **res;
int i, nframes;
GSList *l;
res = g_new0 (StackFrame*, nframes);
l = user_data.frames;
for (i = 0; i < nframes; ++i) {
- res [i] = l->data;
+ res [i] = (StackFrame *)l->data;
l = l->next;
}
*out_nframes = nframes;
GSList *tmp;
int i, findex, new_frame_count;
StackFrame **new_frames, *f;
- MonoUnwindOptions opts = MONO_UNWIND_DEFAULT|MONO_UNWIND_REG_LOCATIONS;
+ MonoUnwindOptions opts = (MonoUnwindOptions)(MONO_UNWIND_DEFAULT | MONO_UNWIND_REG_LOCATIONS);
// FIXME: Locking on tls
if (tls->frames && tls->frames_up_to_date)
new_frames = g_new0 (StackFrame*, new_frame_count);
findex = 0;
for (tmp = user_data.frames; tmp; tmp = tmp->next) {
- f = tmp->data;
+ f = (StackFrame *)tmp->data;
/*
* Reuse the id for already existing stack frames, so invokes don't invalidate
emit_appdomain_load (gpointer key, gpointer value, gpointer user_data)
{
process_profiler_event (EVENT_KIND_APPDOMAIN_CREATE, value);
- g_hash_table_foreach (get_agent_domain_info (value)->loaded_classes, emit_type_load, NULL);
+ g_hash_table_foreach (get_agent_domain_info ((MonoDomain *)value)->loaded_classes, emit_type_load, NULL);
}
/*
return NULL;
for (i = 0; i < reqs->len; ++i) {
- EventRequest *req = g_ptr_array_index (reqs, i);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (reqs, i);
if (req->event_kind == event) {
gboolean filtered = FALSE;
if (minfo) {
mono_debug_get_seq_points (minfo, &source_file, &source_file_list, NULL, NULL, NULL);
for (i = 0; i < source_file_list->len; ++i) {
- sinfo = g_ptr_array_index (source_file_list, i);
+ sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, i);
/*
* Do a case-insesitive match by converting the file name to
* lowercase.
thread = mono_thread_current ();
if (event == EVENT_KIND_VM_START && arg != NULL)
- thread = arg;
+ thread = (MonoThread *)arg;
buffer_add_objid (&buf, (MonoObject*)thread); // thread
break;
case EVENT_KIND_APPDOMAIN_CREATE:
case EVENT_KIND_APPDOMAIN_UNLOAD:
- buffer_add_domainid (&buf, arg);
+ buffer_add_domainid (&buf, (MonoDomain *)arg);
break;
case EVENT_KIND_METHOD_ENTRY:
case EVENT_KIND_METHOD_EXIT:
- buffer_add_methodid (&buf, domain, arg);
+ buffer_add_methodid (&buf, domain, (MonoMethod *)arg);
break;
case EVENT_KIND_ASSEMBLY_LOAD:
- buffer_add_assemblyid (&buf, domain, arg);
+ buffer_add_assemblyid (&buf, domain, (MonoAssembly *)arg);
break;
case EVENT_KIND_ASSEMBLY_UNLOAD: {
DebuggerTlsData *tls;
/* The domain the assembly belonged to is not equal to the current domain */
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
g_assert (tls->domain_unloading);
- buffer_add_assemblyid (&buf, tls->domain_unloading, arg);
+ buffer_add_assemblyid (&buf, tls->domain_unloading, (MonoAssembly *)arg);
break;
}
case EVENT_KIND_TYPE_LOAD:
- buffer_add_typeid (&buf, domain, arg);
+ buffer_add_typeid (&buf, domain, (MonoClass *)arg);
break;
case EVENT_KIND_BREAKPOINT:
case EVENT_KIND_STEP:
- buffer_add_methodid (&buf, domain, arg);
+ buffer_add_methodid (&buf, domain, (MonoMethod *)arg);
buffer_add_long (&buf, il_offset);
break;
case EVENT_KIND_VM_START:
buffer_add_int (&buf, mono_environment_exitcode_get ());
break;
case EVENT_KIND_EXCEPTION: {
- EventInfo *ei = arg;
+ EventInfo *ei = (EventInfo *)arg;
buffer_add_objid (&buf, ei->exc);
/*
* We are not yet suspending, so get_objref () will not keep this object alive. So we need to do it
case EVENT_KIND_USER_BREAK:
break;
case EVENT_KIND_USER_LOG: {
- EventInfo *ei = arg;
+ EventInfo *ei = (EventInfo *)arg;
buffer_add_int (&buf, ei->level);
buffer_add_string (&buf, ei->category ? ei->category : "");
buffer_add_string (&buf, ei->message ? ei->message : "");
EventInfo ei, *ei_arg = NULL;
if (event == EVENT_KIND_TYPE_LOAD) {
- ei.klass = arg;
+ ei.klass = (MonoClass *)arg;
ei_arg = &ei;
}
g_assert (mono_native_thread_id_equals (MONO_UINT_TO_NATIVE_THREAD_ID (tid), MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid)));
mono_loader_lock ();
- old_thread = mono_g_hash_table_lookup (tid_to_thread, GUINT_TO_POINTER (tid));
+ old_thread = (MonoInternalThread *)mono_g_hash_table_lookup (tid_to_thread, GUINT_TO_POINTER (tid));
mono_loader_unlock ();
if (old_thread) {
if (thread == old_thread) {
}
}
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (!tls);
// FIXME: Free this somewhere
tls = g_new0 (DebuggerTlsData, 1);
DebuggerTlsData *tls = NULL;
mono_loader_lock ();
- thread = mono_g_hash_table_lookup (tid_to_thread, GUINT_TO_POINTER (tid));
+ thread = (MonoInternalThread *)mono_g_hash_table_lookup (tid_to_thread, GUINT_TO_POINTER (tid));
if (thread) {
mono_g_hash_table_remove (tid_to_thread_obj, GUINT_TO_POINTER (tid));
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
if (tls) {
/* FIXME: Maybe we need to free this instead, but some code can't handle that */
tls->terminated = TRUE;
* Remember the currently unloading appdomain as it is needed to generate
* proper ids for unloading assemblies.
*/
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
tls->domain_unloading = domain;
}
if (is_debugger_thread ())
return;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
tls->domain_unloading = NULL;
static void
invalidate_each_thread (gpointer key, gpointer value, gpointer user_data)
{
- invalidate_frames (value);
+ invalidate_frames ((DebuggerTlsData *)value);
}
static void
// FIXME: Maybe store this in TLS so the thread of the event is correct ?
dbg_lock ();
if (pending_assembly_loads->len > 0) {
- assembly = g_ptr_array_index (pending_assembly_loads, 0);
+ assembly = (MonoAssembly *)g_ptr_array_index (pending_assembly_loads, 0);
g_ptr_array_remove_index (pending_assembly_loads, 0);
}
dbg_unlock ();
mono_loader_lock ();
for (i = 0; i < breakpoints->len; ++i) {
- MonoBreakpoint *bp = g_ptr_array_index (breakpoints, i);
+ MonoBreakpoint *bp = (MonoBreakpoint *)g_ptr_array_index (breakpoints, i);
gboolean found = FALSE;
if (!bp_matches_method (bp, method))
continue;
for (j = 0; j < bp->children->len; ++j) {
- BreakpointInstance *inst = g_ptr_array_index (bp->children, j);
+ BreakpointInstance *inst = (BreakpointInstance *)g_ptr_array_index (bp->children, j);
if (inst->ji == ji)
found = TRUE;
declaring = mono_method_get_declaring_generic_method (jmethod);
mono_domain_lock (domain);
- seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, jmethod);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, jmethod);
if (!seq_points && declaring)
- seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring);
mono_domain_unlock (domain);
if (!seq_points)
/* Could be AOT code */
/* Might be AOTed code */
code = mono_aot_get_method (domain, method);
g_assert (code);
- ji = mono_jit_info_table_find (domain, code);
+ ji = mono_jit_info_table_find (domain, (char *)code);
g_assert (ji);
}
g_assert (code);
}
for (i = 0; i < methods->len; ++i) {
- m = g_ptr_array_index (methods, i);
- domain = g_ptr_array_index (method_domains, i);
- seq_points = g_ptr_array_index (method_seq_points, i);
+ m = (MonoMethod *)g_ptr_array_index (methods, i);
+ domain = (MonoDomain *)g_ptr_array_index (method_domains, i);
+ seq_points = (MonoSeqPointInfo *)g_ptr_array_index (method_seq_points, i);
set_bp_in_method (domain, m, seq_points, bp, error);
}
// FIXME: locking, races
for (i = 0; i < bp->children->len; ++i) {
- BreakpointInstance *inst = g_ptr_array_index (bp->children, i);
+ BreakpointInstance *inst = (BreakpointInstance *)g_ptr_array_index (bp->children, i);
remove_breakpoint (inst);
mono_loader_lock ();
i = 0;
while (i < event_requests->len) {
- EventRequest *req = g_ptr_array_index (event_requests, i);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
if (req->event_kind == EVENT_KIND_BREAKPOINT) {
- clear_breakpoint (req->info);
+ clear_breakpoint ((MonoBreakpoint *)req->info);
g_ptr_array_remove_index_fast (event_requests, i);
g_free (req);
} else {
mono_loader_lock ();
for (i = 0; i < breakpoints->len; ++i) {
- MonoBreakpoint *bp = g_ptr_array_index (breakpoints, i);
+ MonoBreakpoint *bp = (MonoBreakpoint *)g_ptr_array_index (breakpoints, i);
j = 0;
while (j < bp->children->len) {
- BreakpointInstance *inst = g_ptr_array_index (bp->children, j);
+ BreakpointInstance *inst = (BreakpointInstance *)g_ptr_array_index (bp->children, j);
if (inst->domain == domain) {
remove_breakpoint (inst);
// FIXME: Speed this up
- ip = MONO_CONTEXT_GET_IP (ctx);
+ ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, NULL);
g_assert (ji && !ji->is_trampoline);
method = jinfo_get_method (ji);
bp = NULL;
for (i = 0; i < breakpoints->len; ++i) {
- bp = g_ptr_array_index (breakpoints, i);
+ bp = (MonoBreakpoint *)g_ptr_array_index (breakpoints, i);
if (!bp->method)
continue;
for (j = 0; j < bp->children->len; ++j) {
- inst = g_ptr_array_index (bp->children, j);
+ inst = (BreakpointInstance *)g_ptr_array_index (bp->children, j);
if (inst->ji == ji && inst->il_offset == sp.il_offset && inst->native_offset == sp.native_offset) {
if (bp->req->event_kind == EVENT_KIND_STEP) {
g_ptr_array_add (ss_reqs_orig, bp->req);
/* Process single step requests */
for (i = 0; i < ss_reqs_orig->len; ++i) {
- EventRequest *req = g_ptr_array_index (ss_reqs_orig, i);
- SingleStepReq *ss_req = req->info;
+ EventRequest *req = (EventRequest *)g_ptr_array_index (ss_reqs_orig, i);
+ SingleStepReq *ss_req = (SingleStepReq *)req->info;
gboolean hit;
if (mono_thread_internal_current () != ss_req->thread)
MonoThreadUnwindState orig_restore_state;
MonoContext ctx;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
/* Have to save/restore the restore_ctx as we can be called recursively during invokes etc. */
memcpy (&orig_restore_state, &tls->restore_state, sizeof (MonoThreadUnwindState));
mono_thread_state_init_from_monoctx (&tls->restore_state, &tls->handler_ctx);
/* Save the original context in TLS */
// FIXME: This might not work on an altstack ?
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
if (!tls)
fprintf (stderr, "Thread %p is not attached to the JIT.\n", (gpointer)mono_native_thread_id_get ());
g_assert (tls);
/* Obtain a context */
MONO_CONTEXT_SET_IP (&ctx, NULL);
- mono_walk_stack_with_ctx (user_break_cb, NULL, 0, &ctx);
+ mono_walk_stack_with_ctx (user_break_cb, NULL, (MonoUnwindOptions)0, &ctx);
g_assert (MONO_CONTEXT_GET_IP (&ctx) != NULL);
mono_loader_lock ();
SeqPoint sp;
MonoSeqPointInfo *info;
- ip = MONO_CONTEXT_GET_IP (ctx);
+ ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
/* Skip the instruction causing the single step */
if (from_signal)
DebuggerTlsData *tls;
MonoThreadUnwindState orig_restore_state;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
/* Fastpath during invokes, see in process_suspend () */
if (tls && suspend_count && suspend_count - tls->resume_count == 0)
return;
if (is_debugger_thread ())
return;
- orig_ip = MONO_CONTEXT_GET_IP (ctx);
+ orig_ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
MONO_CONTEXT_SET_IP (ctx, orig_ip - 1);
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
memcpy (&orig_restore_state, &tls->restore_state, sizeof (MonoThreadUnwindState));
mono_thread_state_init_from_monoctx (&tls->restore_state, ctx);
GSList *l;
for (l = ss_req->bps; l; l = l->next) {
- clear_breakpoint (l->data);
+ clear_breakpoint ((MonoBreakpoint *)l->data);
}
g_slist_free (ss_req->bps);
ss_req->bps = NULL;
req->info = ss_req;
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
mono_loader_unlock ();
g_assert (tls);
g_assert (tls->context.valid);
*/
/* Find the the jit info for the catch context */
- res = mono_find_jit_info_ext (tls->catch_state.unwind_data [MONO_UNWIND_DATA_DOMAIN], ((MonoThreadInfo*)thread->thread_info)->jit_data, NULL, &tls->catch_state.ctx, &new_ctx, NULL, &lmf, NULL, &frame);
+ res = mono_find_jit_info_ext (
+ (MonoDomain *)tls->catch_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
+ (MonoJitTlsData *)((MonoThreadInfo*)thread->thread_info)->jit_data,
+ NULL, &tls->catch_state.ctx, &new_ctx, NULL, &lmf, NULL, &frame);
g_assert (res);
g_assert (frame.type == FRAME_TYPE_MANAGED);
if (frames)
free_frames (frames, nframes);
- return 0;
+ return ERR_NONE;
}
static void
while (found) {
found = FALSE;
for (l = ss_req->bps; l; l = l->next) {
- if (breakpoint_matches_assembly (l->data, assembly)) {
- clear_breakpoint (l->data);
+ if (breakpoint_matches_assembly ((MonoBreakpoint *)l->data, assembly)) {
+ clear_breakpoint ((MonoBreakpoint *)l->data);
ss_req->bps = g_slist_delete_link (ss_req->bps, l);
found = TRUE;
break;
MonoInternalThread *thread = mono_thread_internal_current ();
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
mono_loader_unlock ();
if (tls && tls->abort_requested)
gboolean found = FALSE;
for (l = agent_config.onthrow; l; l = l->next) {
- char *ex_type = l->data;
+ char *ex_type = (char *)l->data;
char *f = mono_type_full_name (&exc->object.vtable->klass->byval_arg);
if (!strcmp (ex_type, "") || !strcmp (ex_type, f))
if (!inited)
return;
- ji = mini_jit_info_table_find (mono_domain_get (), MONO_CONTEXT_GET_IP (throw_ctx), NULL);
+ ji = mini_jit_info_table_find (mono_domain_get (), (char *)MONO_CONTEXT_GET_IP (throw_ctx), NULL);
if (catch_ctx)
- catch_ji = mini_jit_info_table_find (mono_domain_get (), MONO_CONTEXT_GET_IP (catch_ctx), NULL);
+ catch_ji = mini_jit_info_table_find (mono_domain_get (), (char *)MONO_CONTEXT_GET_IP (catch_ctx), NULL);
else
catch_ji = NULL;
/* Treat exceptions which are caught in non-user code as unhandled */
for (i = 0; i < event_requests->len; ++i) {
- EventRequest *req = g_ptr_array_index (event_requests, i);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
if (req->event_kind != EVENT_KIND_EXCEPTION)
continue;
if (!inited)
return;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
if (!tls)
return;
if (!inited)
return;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
if (!tls)
return;
int nfields;
gpointer iter = NULL;
MonoDomain *d;
- int err;
+ ErrorCode err;
is_enum = decode_byte (buf, &buf, limit);
/* Enums are sent as a normal vtype */
if (is_enum)
return ERR_NOT_IMPLEMENTED;
klass = decode_typeid (buf, &buf, limit, &d, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
if (t && klass != mono_class_from_mono_type (t)) {
if (mono_field_is_deleted (f))
continue;
err = decode_value (f->type, domain, (guint8*)addr + f->offset - sizeof (MonoObject), buf, &buf, limit);
- if (err)
+ if (err != ERR_NONE)
return err;
nfields --;
}
*endbuf = buf;
- return 0;
+ return ERR_NONE;
}
static ErrorCode
decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit)
{
- int err;
+ ErrorCode err;
if (type != t->type && !MONO_TYPE_IS_REFERENCE (t) &&
!(t->type == MONO_TYPE_I && type == MONO_TYPE_VALUETYPE) &&
if (type == MONO_TYPE_OBJECT) {
/* Boxed vtype */
int objid = decode_objid (buf, &buf, limit);
- int err;
+ ErrorCode err;
MonoObject *obj;
err = get_object (objid, (MonoObject**)&obj);
- if (err)
+ if (err != ERR_NONE)
return err;
if (!obj)
return ERR_INVALID_ARGUMENT;
memcpy (addr, mono_object_unbox (obj), mono_class_value_size (obj->vtable->klass, NULL));
} else {
err = decode_vtype (t, domain, addr, buf, &buf, limit);
- if (err)
+ if (err != ERR_NONE)
return err;
}
break;
if (MONO_TYPE_IS_REFERENCE (t)) {
if (type == MONO_TYPE_OBJECT) {
int objid = decode_objid (buf, &buf, limit);
- int err;
+ ErrorCode err;
MonoObject *obj;
err = get_object (objid, (MonoObject**)&obj);
- if (err)
+ if (err != ERR_NONE)
return err;
if (obj) {
if (is_enum)
return ERR_NOT_IMPLEMENTED;
klass = decode_typeid (buf, &buf, limit, &d, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
/* Decode the vtype into a temporary buffer, then box it. */
vtype_buf_size = mono_class_value_size (klass, NULL);
- vtype_buf = g_malloc0 (vtype_buf_size);
+ vtype_buf = (guint8 *)g_malloc0 (vtype_buf_size);
g_assert (vtype_buf);
buf = buf2;
err = decode_vtype (NULL, domain, vtype_buf, buf, &buf, limit);
- if (err) {
+ if (err != ERR_NONE) {
g_free (vtype_buf);
return err;
}
*endbuf = buf;
- return 0;
+ return ERR_NONE;
}
static ErrorCode
decode_value (MonoType *t, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit)
{
- int err;
+ ErrorCode err;
int type = decode_byte (buf, &buf, limit);
if (t->type == MONO_TYPE_GENERICINST && mono_class_is_nullable (mono_class_from_mono_type (t))) {
* First try decoding it as a Nullable`1
*/
err = decode_value_internal (t, type, domain, addr, buf, endbuf, limit);
- if (!err)
+ if (err == ERR_NONE)
return err;
/*
* Then try decoding as a primitive value or null.
*/
if (targ->type == type) {
- nullable_buf = g_malloc (mono_class_instance_size (mono_class_from_mono_type (targ)));
+ nullable_buf = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (targ)));
err = decode_value_internal (targ, type, domain, nullable_buf, buf, endbuf, limit);
- if (err) {
+ if (err != ERR_NONE) {
g_free (nullable_buf);
return err;
}
buffer_add_value_full (buf, t, ®_val, domain, as_vtype, NULL);
break;
case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
addr += (gint32)var->offset;
//printf ("[R%d+%d] = %p\n", reg, var->offset, addr);
case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
case MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR:
/* Same as regoffset, but with an indirection */
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
addr += (gint32)var->offset;
- gaddr = *(gpointer*)addr;
+ gaddr = (guint8 *)*(gpointer*)addr;
g_assert (gaddr);
buffer_add_value_full (buf, t, gaddr, domain, as_vtype, NULL);
break;
flags = info_var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
reg = info_var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET) {
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
addr += (gint32)info_var->offset;
- info = *(gpointer*)addr;
+ info = (MonoGSharedVtMethodRuntimeInfo *)*(gpointer*)addr;
} else if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER) {
- info = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ info = (MonoGSharedVtMethodRuntimeInfo *)mono_arch_context_get_int_reg (ctx, reg);
} else {
g_assert_not_reached ();
}
flags = locals_var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
reg = locals_var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET) {
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
addr += (gint32)locals_var->offset;
- locals = *(gpointer*)addr;
+ locals = (guint8 *)*(gpointer*)addr;
} else if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER) {
- locals = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ locals = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
} else {
g_assert_not_reached ();
}
gboolean is_signed = FALSE;
if (t->byref) {
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
if (addr) {
// FIXME: Write barriers
break;
}
case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
addr += (gint32)var->offset;
//printf ("[R%d+%d] = %p\n", reg, var->offset, addr);
break;
case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
/* Same as regoffset, but with an indirection */
- addr = (gpointer)mono_arch_context_get_int_reg (ctx, reg);
+ addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
addr += (gint32)var->offset;
- gaddr = *(gpointer*)addr;
+ gaddr = (guint8 *)*(gpointer*)addr;
g_assert (gaddr);
// FIXME: Write barriers
mono_gc_memmove_atomic (gaddr, val, size);
mono_loader_lock ();
for (i = 0; i < event_requests->len; ++i) {
- EventRequest *req = g_ptr_array_index (event_requests, i);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
if (req->id == req_id && req->event_kind == etype) {
if (req->event_kind == EVENT_KIND_BREAKPOINT)
- clear_breakpoint (req->info);
+ clear_breakpoint ((MonoBreakpoint *)req->info);
if (req->event_kind == EVENT_KIND_STEP)
- ss_destroy (req->info);
+ ss_destroy ((SingleStepReq *)req->info);
if (req->event_kind == EVENT_KIND_METHOD_ENTRY)
- clear_breakpoint (req->info);
+ clear_breakpoint ((MonoBreakpoint *)req->info);
if (req->event_kind == EVENT_KIND_METHOD_EXIT)
- clear_breakpoint (req->info);
+ clear_breakpoint ((MonoBreakpoint *)req->info);
g_ptr_array_remove_index_fast (event_requests, i);
g_free (req);
break;
while (found) {
found = FALSE;
for (i = 0; i < event_requests->len; ++i) {
- EventRequest *req = g_ptr_array_index (event_requests, i);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
clear_assembly_from_modifiers (req, assembly);
- if (req->event_kind == EVENT_KIND_BREAKPOINT && breakpoint_matches_assembly (req->info, assembly)) {
+ if (req->event_kind == EVENT_KIND_BREAKPOINT && breakpoint_matches_assembly ((MonoBreakpoint *)req->info, assembly)) {
clear_event_request (req->id, req->event_kind);
found = TRUE;
break;
}
if (req->event_kind == EVENT_KIND_STEP)
- ss_clear_for_assembly (req->info, assembly);
+ ss_clear_for_assembly ((SingleStepReq *)req->info, assembly);
}
}
mono_loader_unlock ();
static void
add_thread (gpointer key, gpointer value, gpointer user_data)
{
- MonoInternalThread *thread = value;
- Buffer *buf = user_data;
+ MonoInternalThread *thread = (MonoInternalThread *)value;
+ Buffer *buf = (Buffer *)user_data;
buffer_add_objid (buf, (MonoObject*)thread);
}
{
guint8 *end = invoke->endp;
MonoMethod *m;
- int i, err, nargs;
+ int i, nargs;
+ ErrorCode err;
MonoMethodSignature *sig;
guint8 **arg_buf;
void **args;
}
m = decode_methodid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
sig = mono_method_signature (m);
if (m->klass->valuetype)
- this_buf = g_alloca (mono_class_instance_size (m->klass));
+ this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass));
else
- this_buf = g_alloca (sizeof (MonoObject*));
+ this_buf = (guint8 *)g_alloca (sizeof (MonoObject*));
if (m->klass->valuetype && (m->flags & METHOD_ATTRIBUTE_STATIC)) {
/* Should be null */
int type = decode_byte (p, &p, end);
p = tmp_p;
} else {
err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end);
- if (err)
+ if (err != ERR_NONE)
return err;
}
} else {
err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end);
- if (err)
+ if (err != ERR_NONE)
return err;
}
m = mono_object_get_virtual_method (this_arg, m);
/* Transform this to the format the rest of the code expects it to be */
if (m->klass->valuetype) {
- this_buf = g_alloca (mono_class_instance_size (m->klass));
+ this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass));
memcpy (this_buf, mono_object_unbox (this_arg), mono_class_instance_size (m->klass));
}
} else if ((m->flags & METHOD_ATTRIBUTE_VIRTUAL) && !m->klass->valuetype && invoke->flags & INVOKE_FLAG_VIRTUAL) {
}
m = mono_object_get_virtual_method (this_arg, m);
if (m->klass->valuetype) {
- this_buf = g_alloca (mono_class_instance_size (m->klass));
+ this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass));
memcpy (this_buf, mono_object_unbox (this_arg), mono_class_instance_size (m->klass));
}
}
if (nargs != sig->param_count)
return ERR_INVALID_ARGUMENT;
/* Use alloca to get gc tracking */
- arg_buf = g_alloca (nargs * sizeof (gpointer));
+ arg_buf = (guint8 **)g_alloca (nargs * sizeof (gpointer));
memset (arg_buf, 0, nargs * sizeof (gpointer));
- args = g_alloca (nargs * sizeof (gpointer));
+ args = (gpointer *)g_alloca (nargs * sizeof (gpointer));
for (i = 0; i < nargs; ++i) {
if (MONO_TYPE_IS_REFERENCE (sig->params [i])) {
err = decode_value (sig->params [i], domain, (guint8*)&args [i], p, &p, end);
- if (err)
+ if (err != ERR_NONE)
break;
if (args [i] && ((MonoObject*)args [i])->vtable->domain != domain)
NOT_IMPLEMENTED;
if (sig->params [i]->byref) {
- arg_buf [i] = g_alloca (sizeof (mgreg_t));
+ arg_buf [i] = (guint8 *)g_alloca (sizeof (mgreg_t));
*(gpointer*)arg_buf [i] = args [i];
args [i] = arg_buf [i];
}
} else {
- arg_buf [i] = g_alloca (mono_class_instance_size (mono_class_from_mono_type (sig->params [i])));
+ arg_buf [i] = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type (sig->params [i])));
err = decode_value (sig->params [i], domain, arg_buf [i], p, &p, end);
- if (err)
+ if (err != ERR_NONE)
break;
args [i] = arg_buf [i];
}
} else if (mono_class_from_mono_type (sig->ret)->valuetype || sig->ret->type == MONO_TYPE_PTR || sig->ret->type == MONO_TYPE_FNPTR) {
if (mono_class_is_nullable (mono_class_from_mono_type (sig->ret))) {
MonoClass *k = mono_class_from_mono_type (sig->ret);
- guint8 *nullable_buf = g_alloca (mono_class_value_size (k, NULL));
+ guint8 *nullable_buf = (guint8 *)g_alloca (mono_class_value_size (k, NULL));
g_assert (nullable_buf);
mono_nullable_init (nullable_buf, res, k);
#ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
if (invoke->has_ctx)
- mono_set_lmf ((gpointer)(((gssize)ext.lmf.previous_lmf) & ~3));
+ mono_set_lmf ((MonoLMF *)(((gssize)ext.lmf.previous_lmf) & ~3));
#endif
*endp = p;
DebuggerTlsData *tls;
InvokeData *invoke;
int id;
- int i, err, mindex;
+ int i, mindex;
+ ErrorCode err;
Buffer buf;
MonoContext restore_ctx;
guint8 *p;
- tls = mono_native_tls_get_value (debugger_tls_id);
+ tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
g_assert (tls);
/*
id = invoke->id;
p = invoke->p;
- err = 0;
+ err = ERR_NONE;
for (mindex = 0; mindex < invoke->nmethods; ++mindex) {
buffer_init (&buf, 128);
static gboolean
is_really_suspended (gpointer key, gpointer value, gpointer user_data)
{
- MonoThread *thread = value;
+ MonoThread *thread = (MonoThread *)value;
DebuggerTlsData *tls;
gboolean res;
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
g_assert (tls);
res = tls->really_suspended;
mono_loader_unlock ();
if (minfo) {
mono_debug_get_seq_points (minfo, NULL, &source_file_list, NULL, NULL, NULL);
for (j = 0; j < source_file_list->len; ++j) {
- sinfo = g_ptr_array_index (source_file_list, j);
+ sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, j);
for (i = 0; i < files->len; ++i)
if (!strcmp (g_ptr_array_index (files, i), sinfo->source_file))
break;
/* Clear all event requests */
mono_loader_lock ();
while (event_requests->len > 0) {
- EventRequest *req = g_ptr_array_index (event_requests, 0);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, 0);
clear_event_request (req->id, req->event_kind);
}
/* Clear all event requests */
mono_loader_lock ();
while (event_requests->len > 0) {
- EventRequest *req = g_ptr_array_index (event_requests, 0);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, 0);
clear_event_request (req->id, req->event_kind);
}
#endif
mono_loader_lock ();
- thread = mono_g_hash_table_find (tid_to_thread, is_really_suspended, NULL);
+ thread = (MonoInternalThread *)mono_g_hash_table_find (tid_to_thread, is_really_suspended, NULL);
mono_loader_unlock ();
if (thread && exit_method) {
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
mono_loader_unlock ();
args = g_new0 (gpointer, 1);
int objid = decode_objid (p, &p, end);
MonoThread *thread;
DebuggerTlsData *tls;
- int i, count, err, flags, nmethods;
+ int i, count, flags, nmethods;
+ ErrorCode err;
err = get_object (objid, (MonoObject**)&thread);
- if (err)
+ if (err != ERR_NONE)
return err;
flags = decode_int (p, &p, end);
return ERR_NOT_SUSPENDED;
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
mono_loader_unlock ();
g_assert (tls);
tls->pending_invoke = g_new0 (InvokeData, 1);
tls->pending_invoke->id = id;
tls->pending_invoke->flags = flags;
- tls->pending_invoke->p = g_malloc (end - p);
+ tls->pending_invoke->p = (guint8 *)g_malloc (end - p);
memcpy (tls->pending_invoke->p, p, end - p);
tls->pending_invoke->endp = tls->pending_invoke->p + (end - p);
tls->pending_invoke->suspend_count = suspend_count;
int objid = decode_objid (p, &p, end);
MonoThread *thread;
DebuggerTlsData *tls;
- int invoke_id, err;
+ int invoke_id;
+ ErrorCode err;
err = get_object (objid, (MonoObject**)&thread);
- if (err)
+ if (err != ERR_NONE)
return err;
invoke_id = decode_int (p, &p, end);
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
g_assert (tls);
if (tls->abort_requested) {
mono_loader_lock ();
g_hash_table_iter_init (&iter, domains);
while (g_hash_table_iter_next (&iter, NULL, (void**)&domain)) {
- AgentDomainInfo *info = domain_jit_info (domain)->agent_info;
+ AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
/* Update 'source_file_to_class' cache */
g_hash_table_iter_init (&kiter, info->loaded_classes);
g_hash_table_insert (info->source_files, klass, files);
for (i = 0; i < files->len; ++i) {
- char *s = g_ptr_array_index (files, i);
+ char *s = (char *)g_ptr_array_index (files, i);
char *s2 = dbg_path_get_basename (s);
char *s3;
- class_list = g_hash_table_lookup (info->source_file_to_class, s2);
+ class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class, s2);
if (!class_list) {
class_list = g_slist_prepend (class_list, klass);
g_hash_table_insert (info->source_file_to_class, g_strdup (s2), class_list);
/* The _ignorecase hash contains the lowercase path */
s3 = strdup_tolower (s2);
- class_list = g_hash_table_lookup (info->source_file_to_class_ignorecase, s3);
+ class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class_ignorecase, s3);
if (!class_list) {
class_list = g_slist_prepend (class_list, klass);
g_hash_table_insert (info->source_file_to_class_ignorecase, g_strdup (s3), class_list);
char *s;
s = strdup_tolower (basename);
- class_list = g_hash_table_lookup (info->source_file_to_class_ignorecase, s);
+ class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class_ignorecase, s);
g_free (s);
} else {
- class_list = g_hash_table_lookup (info->source_file_to_class, basename);
+ class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class, basename);
}
for (l = class_list; l; l = l->next) {
- klass = l->data;
+ klass = (MonoClass *)l->data;
g_ptr_array_add (res_classes, klass);
g_ptr_array_add (res_domains, domain);
buffer_add_int (buf, res_classes->len);
for (i = 0; i < res_classes->len; ++i)
- buffer_add_typeid (buf, g_ptr_array_index (res_domains, i), g_ptr_array_index (res_classes, i));
+ buffer_add_typeid (buf, (MonoDomain *)g_ptr_array_index (res_domains, i), (MonoClass *)g_ptr_array_index (res_classes, i));
g_ptr_array_free (res_classes, TRUE);
g_ptr_array_free (res_domains, TRUE);
break;
mono_domain_assemblies_lock (domain);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- ass = tmp->data;
+ ass = (MonoAssembly *)tmp->data;
if (ass->image) {
type_resolve = TRUE;
buffer_add_int (buf, res_classes->len);
for (i = 0; i < res_classes->len; ++i)
- buffer_add_typeid (buf, g_ptr_array_index (res_domains, i), g_ptr_array_index (res_classes, i));
+ buffer_add_typeid (buf, (MonoDomain *)g_ptr_array_index (res_domains, i), (MonoClass *)g_ptr_array_index (res_classes, i));
g_ptr_array_free (res_classes, TRUE);
g_ptr_array_free (res_domains, TRUE);
break;
static ErrorCode
event_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int err;
+ ErrorCode err;
MonoError error;
switch (command) {
case CMD_EVENT_REQUEST_SET: {
EventRequest *req;
- int i, event_kind, suspend_policy, nmodifiers, mod;
+ int i, event_kind, suspend_policy, nmodifiers;
+ ModifierKind mod;
MonoMethod *method;
long location = 0;
MonoThread *step_thread;
- int size = 0, depth = 0, filter = 0, step_thread_id = 0;
+ int step_thread_id = 0;
+ StepDepth depth = STEP_DEPTH_INTO;
+ StepSize size = STEP_SIZE_MIN;
+ StepFilter filter = STEP_FILTER_NONE;
MonoDomain *domain;
Modifier *modifier;
suspend_policy = decode_byte (p, &p, end);
nmodifiers = decode_byte (p, &p, end);
- req = g_malloc0 (sizeof (EventRequest) + (nmodifiers * sizeof (Modifier)));
+ req = (EventRequest *)g_malloc0 (sizeof (EventRequest) + (nmodifiers * sizeof (Modifier)));
req->id = InterlockedIncrement (&event_request_id);
req->event_kind = event_kind;
req->suspend_policy = suspend_policy;
method = NULL;
for (i = 0; i < nmodifiers; ++i) {
- mod = decode_byte (p, &p, end);
+ mod = (ModifierKind)decode_byte (p, &p, end);
req->modifiers [i].kind = mod;
if (mod == MOD_KIND_COUNT) {
req->modifiers [i].data.count = decode_int (p, &p, end);
} else if (mod == MOD_KIND_LOCATION_ONLY) {
method = decode_methodid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
location = decode_long (p, &p, end);
} else if (mod == MOD_KIND_STEP) {
step_thread_id = decode_id (p, &p, end);
- size = decode_int (p, &p, end);
- depth = decode_int (p, &p, end);
+ size = (StepSize)decode_int (p, &p, end);
+ depth = (StepDepth)decode_int (p, &p, end);
if (CHECK_PROTOCOL_VERSION (2, 16))
- filter = decode_int (p, &p, end);
+ filter = (StepFilter)decode_int (p, &p, end);
req->modifiers [i].data.filter = filter;
if (!CHECK_PROTOCOL_VERSION (2, 26) && (req->modifiers [i].data.filter & STEP_FILTER_DEBUGGER_HIDDEN))
/* Treat STEP_THOUGH the same as HIDDEN */
- req->modifiers [i].data.filter |= STEP_FILTER_DEBUGGER_STEP_THROUGH;
+ req->modifiers [i].data.filter = (StepFilter)(req->modifiers [i].data.filter | STEP_FILTER_DEBUGGER_STEP_THROUGH);
} else if (mod == MOD_KIND_THREAD_ONLY) {
int id = decode_id (p, &p, end);
err = get_object (id, (MonoObject**)&req->modifiers [i].data.thread);
- if (err) {
+ if (err != ERR_NONE) {
g_free (req);
return err;
}
} else if (mod == MOD_KIND_EXCEPTION_ONLY) {
MonoClass *exc_class = decode_typeid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
req->modifiers [i].caught = decode_byte (p, &p, end);
req->modifiers [i].uncaught = decode_byte (p, &p, end);
req->modifiers [i].data.assemblies = g_new0 (MonoAssembly*, n);
for (j = 0; j < n; ++j) {
req->modifiers [i].data.assemblies [j] = decode_assemblyid (p, &p, end, &domain, &err);
- if (err) {
+ if (err != ERR_NONE) {
g_free (req->modifiers [i].data.assemblies);
return err;
}
g_assert (step_thread_id);
err = get_object (step_thread_id, (MonoObject**)&step_thread);
- if (err) {
+ if (err != ERR_NONE) {
g_free (req);
return err;
}
err = ss_create (THREAD_TO_INTERNAL (step_thread), size, depth, filter, req);
- if (err) {
+ if (err != ERR_NONE) {
g_free (req);
return err;
}
mono_loader_lock ();
i = 0;
while (i < event_requests->len) {
- EventRequest *req = g_ptr_array_index (event_requests, i);
+ EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
if (req->event_kind == EVENT_KIND_BREAKPOINT) {
- clear_breakpoint (req->info);
+ clear_breakpoint ((MonoBreakpoint *)req->info);
g_ptr_array_remove_index_fast (event_requests, i);
g_free (req);
static ErrorCode
domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int err;
+ ErrorCode err;
MonoDomain *domain;
switch (command) {
}
case CMD_APPDOMAIN_GET_FRIENDLY_NAME: {
domain = decode_domainid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
buffer_add_string (buf, domain->friendly_name);
break;
int count;
domain = decode_domainid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
mono_loader_lock ();
count = 0;
}
buffer_add_int (buf, count);
for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
- ass = tmp->data;
+ ass = (MonoAssembly *)tmp->data;
buffer_add_assemblyid (buf, domain, ass);
}
mono_loader_unlock ();
}
case CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY: {
domain = decode_domainid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
buffer_add_assemblyid (buf, domain, domain->entry_assembly);
}
case CMD_APPDOMAIN_GET_CORLIB: {
domain = decode_domainid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
buffer_add_assemblyid (buf, domain, domain->domain->mbr.obj.vtable->klass->image->assembly);
MonoString *o;
domain = decode_domainid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
s = decode_string (p, &p, end);
MonoObject *o;
domain = decode_domainid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
klass = decode_typeid (p, &p, end, &domain2, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
// FIXME:
o = mono_object_new (domain, klass);
- err = decode_value (&klass->byval_arg, domain, mono_object_unbox (o), p, &p, end);
- if (err)
+ err = decode_value (&klass->byval_arg, domain, (guint8 *)mono_object_unbox (o), p, &p, end);
+ if (err != ERR_NONE)
return err;
buffer_add_objid (buf, o);
static ErrorCode
assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int err;
+ ErrorCode err;
MonoAssembly *ass;
MonoDomain *domain;
ass = decode_assemblyid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
switch (command) {
static ErrorCode
module_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int err;
+ ErrorCode err;
MonoDomain *domain;
switch (command) {
static ErrorCode
field_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int err;
+ ErrorCode err;
MonoDomain *domain;
switch (command) {
buffer_add_value (buf, t, mono_object_unbox (val), domain);
}
-static int
+static ErrorCode
buffer_add_cattrs (Buffer *buf, MonoDomain *domain, MonoImage *image, MonoClass *attr_klass, MonoCustomAttrInfo *cinfo)
{
int i, j;
MonoType *type;
gpointer iter;
guint8 b;
- int err, nnested;
+ int nnested;
+ ErrorCode err;
char *name;
switch (command) {
attr_klass = decode_typeid (p, &p, end, NULL, &err);
/* attr_klass can be NULL */
- if (err)
+ if (err != ERR_NONE)
return err;
cinfo = mono_custom_attrs_from_class (klass);
err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
- if (err)
+ if (err != ERR_NONE)
return err;
break;
}
MonoClassField *field;
field = decode_fieldid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
attr_klass = decode_typeid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
cinfo = mono_custom_attrs_from_field (klass, field);
err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
- if (err)
+ if (err != ERR_NONE)
return err;
break;
}
MonoProperty *prop;
prop = decode_propertyid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
attr_klass = decode_typeid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
cinfo = mono_custom_attrs_from_property (klass, prop);
err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
- if (err)
+ if (err != ERR_NONE)
return err;
break;
}
if (command == CMD_TYPE_GET_VALUES_2) {
int objid = decode_objid (p, &p, end);
- int err;
+ ErrorCode err;
err = get_object (objid, (MonoObject**)&thread_obj);
- if (err)
+ if (err != ERR_NONE)
return err;
thread = THREAD_TO_INTERNAL (thread_obj);
len = decode_int (p, &p, end);
for (i = 0; i < len; ++i) {
f = decode_fieldid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC))
return ERR_INVALID_FIELDID;
vtable = mono_class_vtable (domain, f->parent);
- val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
+ val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
mono_field_static_get_value_for_thread (thread ? thread : mono_thread_internal_current (), vtable, f, val);
buffer_add_value (buf, f->type, val, domain);
g_free (val);
len = decode_int (p, &p, end);
for (i = 0; i < len; ++i) {
f = decode_fieldid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC))
// FIXME: Check for literal/const
vtable = mono_class_vtable (domain, f->parent);
- val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
+ val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
err = decode_value (f->type, domain, val, p, &p, end);
- if (err) {
+ if (err != ERR_NONE) {
g_free (val);
return err;
}
buffer_add_int (buf, files->len);
for (i = 0; i < files->len; ++i) {
- source_file = g_ptr_array_index (files, i);
+ source_file = (char *)g_ptr_array_index (files, i);
if (command == CMD_TYPE_GET_SOURCE_FILES_2) {
buffer_add_string (buf, source_file);
} else {
case CMD_TYPE_IS_ASSIGNABLE_FROM: {
MonoClass *oklass = decode_typeid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
if (mono_class_is_assignable_from (klass, oklass))
buffer_add_byte (buf, 1);
return ERR_LOADER_ERROR;
buffer_add_int (buf, array->len);
for (i = 0; i < array->len; ++i) {
- MonoMethod *method = g_ptr_array_index (array, i);
+ MonoMethod *method = (MonoMethod *)g_ptr_array_index (array, i);
buffer_add_methodid (buf, domain, method);
}
for (tindex = 0; tindex < len; ++tindex) {
iclass = decode_typeid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
MonoClass *klass;
MonoDomain *old_domain;
MonoDomain *domain;
- int err;
+ ErrorCode err;
klass = decode_typeid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
old_domain = mono_domain_get ();
method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, guint8 *p, guint8 *end, Buffer *buf)
{
MonoMethodHeader *header;
- int err;
+ ErrorCode err;
switch (command) {
case CMD_METHOD_GET_NAME: {
if (CHECK_PROTOCOL_VERSION (2, 13)) {
buffer_add_int (buf, source_file_list->len);
for (i = 0; i < source_file_list->len; ++i) {
- MonoDebugSourceInfo *sinfo = g_ptr_array_index (source_file_list, i);
+ MonoDebugSourceInfo *sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, i);
buffer_add_string (buf, sinfo->source_file);
if (CHECK_PROTOCOL_VERSION (2, 14)) {
for (j = 0; j < 16; ++j)
const char *srcfile = "";
if (source_files [i] != -1) {
- MonoDebugSourceInfo *sinfo = g_ptr_array_index (source_file_list, source_files [i]);
+ MonoDebugSourceInfo *sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, source_files [i]);
srcfile = sinfo->source_file;
}
DEBUG_PRINTF (10, "IL%x -> %s:%d %d %d %d\n", sp->il_offset, srcfile, sp->line, sp->column, sp->end_line, sp->end_column);
if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
val = mono_method_get_wrapper_data (method, token);
- handle_class = mono_method_get_wrapper_data (method, token + 1);
+ handle_class = (MonoClass *)mono_method_get_wrapper_data (method, token + 1);
if (handle_class == NULL) {
// Can't figure out the token type
buffer_add_typeid (buf, domain, mono_class_from_mono_type ((MonoType*)val));
} else if (handle_class == mono_defaults.fieldhandle_class) {
buffer_add_byte (buf, TOKEN_TYPE_FIELD);
- buffer_add_fieldid (buf, domain, val);
+ buffer_add_fieldid (buf, domain, (MonoClassField *)val);
} else if (handle_class == mono_defaults.methodhandle_class) {
buffer_add_byte (buf, TOKEN_TYPE_METHOD);
- buffer_add_methodid (buf, domain, val);
+ buffer_add_methodid (buf, domain, (MonoMethod *)val);
} else if (handle_class == mono_defaults.string_class) {
char *s;
- s = mono_string_to_utf8 (val);
+ s = mono_string_to_utf8 ((MonoString *)val);
buffer_add_byte (buf, TOKEN_TYPE_STRING);
buffer_add_string (buf, s);
g_free (s);
attr_klass = decode_typeid (p, &p, end, NULL, &err);
/* attr_klass can be NULL */
- if (err)
+ if (err != ERR_NONE)
return err;
cinfo = mono_custom_attrs_from_method (method);
err = buffer_add_cattrs (buf, domain, method->klass->image, attr_klass, cinfo);
- if (err)
+ if (err != ERR_NONE)
return err;
break;
}
type_argv = g_new0 (MonoType*, type_argc);
for (i = 0; i < type_argc; ++i) {
klass = decode_typeid (p, &p, end, &d, &err);
- if (err) {
+ if (err != ERR_NONE) {
g_free (type_argv);
return err;
}
static ErrorCode
method_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int err;
+ ErrorCode err;
MonoDomain *old_domain;
MonoDomain *domain;
MonoMethod *method;
method = decode_methodid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
old_domain = mono_domain_get ();
thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
int objid = decode_objid (p, &p, end);
- int err;
+ ErrorCode err;
MonoThread *thread_obj;
MonoInternalThread *thread;
err = get_object (objid, (MonoObject**)&thread_obj);
- if (err)
+ if (err != ERR_NONE)
return err;
thread = THREAD_TO_INTERNAL (thread_obj);
return ERR_NOT_IMPLEMENTED;
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
mono_loader_unlock ();
g_assert (tls);
gint64 il_offset;
method = decode_methodid (p, &p, end, &domain, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
il_offset = decode_long (p, &p, end);
}
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
mono_loader_unlock ();
g_assert (tls);
frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
int objid;
- int err;
+ ErrorCode err;
MonoThread *thread_obj;
MonoInternalThread *thread;
int pos, i, len, frame_idx;
objid = decode_objid (p, &p, end);
err = get_object (objid, (MonoObject**)&thread_obj);
- if (err)
+ if (err != ERR_NONE)
return err;
thread = THREAD_TO_INTERNAL (thread_obj);
id = decode_id (p, &p, end);
mono_loader_lock ();
- tls = mono_g_hash_table_lookup (thread_to_tls, thread);
+ tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
mono_loader_unlock ();
g_assert (tls);
}
if (MONO_TYPE_IS_REFERENCE (t))
- val_buf = g_alloca (sizeof (MonoObject*));
+ val_buf = (guint8 *)g_alloca (sizeof (MonoObject*));
else
- val_buf = g_alloca (mono_class_instance_size (mono_class_from_mono_type (t)));
+ val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type (t)));
err = decode_value (t, frame->domain, val_buf, p, &p, end);
- if (err)
+ if (err != ERR_NONE)
return err;
set_var (t, var, &frame->ctx, frame->domain, val_buf, frame->reg_locations, &tls->restore_state.ctx);
array_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
MonoArray *arr;
- int objid, err, index, len, i, esize;
+ int objid, index, len, i, esize;
+ ErrorCode err;
gpointer elem;
objid = decode_objid (p, &p, end);
err = get_object (objid, (MonoObject**)&arr);
- if (err)
+ if (err != ERR_NONE)
return err;
switch (command) {
for (i = index; i < index + len; ++i) {
elem = (gpointer*)((char*)arr->vector + (i * esize));
- decode_value (&arr->obj.vtable->klass->element_class->byval_arg, arr->obj.vtable->domain, elem, p, &p, end);
+ decode_value (&arr->obj.vtable->klass->element_class->byval_arg, arr->obj.vtable->domain, (guint8 *)elem, p, &p, end);
}
break;
default:
static ErrorCode
string_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int objid, err;
+ int objid;
+ ErrorCode err;
MonoString *str;
char *s;
int i, index, length;
objid = decode_objid (p, &p, end);
err = get_object (objid, (MonoObject**)&str);
- if (err)
+ if (err != ERR_NONE)
return err;
switch (command) {
static ErrorCode
object_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
- int objid, err;
+ int objid;
+ ErrorCode err;
MonoObject *obj;
int len, i;
MonoClassField *f;
if (command == CMD_OBJECT_REF_IS_COLLECTED) {
objid = decode_objid (p, &p, end);
err = get_object (objid, &obj);
- if (err)
+ if (err != ERR_NONE)
buffer_add_int (buf, 1);
else
buffer_add_int (buf, 0);
- return 0;
+ return ERR_NONE;
}
objid = decode_objid (p, &p, end);
err = get_object (objid, &obj);
- if (err)
+ if (err != ERR_NONE)
return err;
MonoClass *obj_type;
for (i = 0; i < len; ++i) {
MonoClassField *f = decode_fieldid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
/* Check that the field belongs to the object */
g_assert (f->type->attrs & FIELD_ATTRIBUTE_STATIC);
vtable = mono_class_vtable (obj->vtable->domain, f->parent);
- val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
+ val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
mono_field_static_get_value (vtable, f, val);
buffer_add_value (buf, f->type, val, obj->vtable->domain);
g_free (val);
for (i = 0; i < len; ++i) {
f = decode_fieldid (p, &p, end, NULL, &err);
- if (err)
+ if (err != ERR_NONE)
return err;
/* Check that the field belongs to the object */
g_assert (f->type->attrs & FIELD_ATTRIBUTE_STATIC);
vtable = mono_class_vtable (obj->vtable->domain, f->parent);
- val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
+ val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
err = decode_value (f->type, obj->vtable->domain, val, p, &p, end);
- if (err) {
+ if (err != ERR_NONE) {
g_free (val);
return err;
}
g_free (val);
} else {
err = decode_value (f->type, obj->vtable->domain, (guint8*)obj + f->offset, p, &p, end);
- if (err)
+ if (err != ERR_NONE)
return err;
}
}
static guint32 WINAPI
debugger_thread (void *arg)
{
- int res, len, id, flags, command_set = 0, command = 0;
+ int res, len, id, flags, command = 0;
+ CommandSet command_set = (CommandSet)0;
guint8 header [HEADER_LENGTH];
guint8 *data, *p, *end;
Buffer buf;
len = decode_int (p, &p, end);
id = decode_int (p, &p, end);
flags = decode_byte (p, &p, end);
- command_set = decode_byte (p, &p, end);
+ command_set = (CommandSet)decode_byte (p, &p, end);
command = decode_byte (p, &p, end);
g_assert (flags == 0);
DEBUG_PRINTF (1, "[dbg] Command %s(%s) [%d][at=%lx].\n", command_set_to_string (command_set), cmd_str, id, (long)mono_100ns_ticks () / 10000);
}
- data = g_malloc (len - HEADER_LENGTH);
+ data = (guint8 *)g_malloc (len - HEADER_LENGTH);
if (len - HEADER_LENGTH > 0)
{
MONO_PREPARE_BLOCKING;
switch (command_set) {
case CMD_SET_VM:
err = vm_commands (command, id, p, end, &buf);
- if (!err && command == CMD_VM_INVOKE_METHOD)
+ if (err == ERR_NONE && command == CMD_VM_INVOKE_METHOD)
/* Sent after the invoke is complete */
no_reply = TRUE;
break;
}
}
- if (!err && command_set == CMD_SET_VM && command == CMD_VM_STOP_BUFFERING) {
+ if (err == ERR_NONE && command_set == CMD_SET_VM && command == CMD_VM_STOP_BUFFERING) {
send_buffered_reply_packets ();
buffer_replies = FALSE;
}
g_assert (!info->sig->hasthis);
g_assert (info->sig->param_count <= MONO_MAX_SRC_REGS);
- args = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * info->sig->param_count);
+ args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * info->sig->param_count);
if (info->sig->param_count > 0) {
int sregs [MONO_MAX_SRC_REGS];
int num_sregs, i;
* Create a dummy bblock and emit code into it so we can use the normal
* code generation macros.
*/
- cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
+ cfg->cbb = (MonoBasicBlock *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
first_bb = cfg->cbb;
/* For LLVM, decompose only the OP_STOREV_MEMBASE opcodes, which need write barriers and the gsharedvt opcodes */
* Create a dummy bblock and emit code into it so we can use the normal
* code generation macros.
*/
- cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
+ cfg->cbb = (MonoBasicBlock *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
first_bb = cfg->cbb;
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
MonoBitSet *dominators;
char *mem;
- mem = mono_mempool_alloc0 (cfg->mempool, bitsize);
+ mem = (char *)mono_mempool_alloc0 (cfg->mempool, bitsize);
bb->dominators = dominators = mono_bitset_mem_new (mem, cfg->num_bblocks, 0);
mem += bitsize;
cfg->bblocks [i]->flags &= ~BB_VISITED;
bitsize = mono_bitset_alloc_size (cfg->num_bblocks, 0);
- mem = mono_mempool_alloc0 (cfg->mempool, bitsize * cfg->num_bblocks);
+ mem = (char *)mono_mempool_alloc0 (cfg->mempool, bitsize * cfg->num_bblocks);
for (i = 0; i < cfg->num_bblocks; ++i) {
MonoBasicBlock *bb = cfg->bblocks [i];
GList *l;
for (l = h->loop_blocks; l; l = l->next) {
- MonoBasicBlock *b = l->data;
+ MonoBasicBlock *b = (MonoBasicBlock *)l->data;
if (b->dfn)
mono_bitset_set_fast (in_loop_blocks, b->dfn);
}
if (verbose >= 2)
g_print ("Running '%s' ...\n", method->name);
#ifdef MONO_USE_AOT_COMPILER
- if ((func = mono_aot_get_method (mono_get_root_domain (), method)))
+ if ((func = (TestMethod)mono_aot_get_method (mono_get_root_domain (), method)))
;
else
#endif
for (iter = mono_single_method_list; iter; iter = g_slist_next (iter)) {
char *method_name;
- mono_current_single_method = iter->data;
+ mono_current_single_method = (MonoMethod *)iter->data;
method_name = mono_method_full_name (mono_current_single_method, TRUE);
g_print ("Current single method: %s\n", method_name);
g_print ("Compiling %d %s\n", count, desc);
g_free (desc);
}
- cfg = mini_method_compile (method, mono_get_optimizations_for_method (method, args->opts), mono_get_root_domain (), 0, 0, -1);
+ cfg = mini_method_compile (method, mono_get_optimizations_for_method (method, args->opts), mono_get_root_domain (), (JitFlags)0, 0, -1);
if (cfg->exception_type != MONO_EXCEPTION_NONE) {
printf ("Compilation of %s failed with exception '%s':\n", mono_method_full_name (cfg->method, TRUE), cfg->exception_message);
fail_count ++;
static void main_thread_handler (gpointer user_data)
{
- MainThreadArgs *main_args = user_data;
+ MainThreadArgs *main_args = (MainThreadArgs *)user_data;
MonoAssembly *assembly;
if (mono_compile_aot) {
MonoImageOpenStatus open_status;
if (col) {
- agent = g_memdup (desc, col - desc + 1);
+ agent = (char *)g_memdup (desc, col - desc + 1);
agent [col - desc] = '\0';
args = col + 1;
} else {
#ifdef GLIBC_BEFORE_2_3_4_SCHED_SETAFFINITY
sched_setaffinity (getpid(), (gpointer)&proc_mask);
#else
- sched_setaffinity (getpid(), sizeof (unsigned long), (gpointer)&proc_mask);
+ sched_setaffinity (getpid(), sizeof (unsigned long), (const cpu_set_t *)&proc_mask);
#endif
}
#endif
char *config_file = NULL;
int i, count = 1;
guint32 opt, action = DO_EXEC, recompilation_times = 1;
- MonoGraphOptions mono_graph_options = 0;
+ MonoGraphOptions mono_graph_options = (MonoGraphOptions)0;
int mini_verbose = 0;
gboolean enable_profile = FALSE;
char *trace_options = NULL;
(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
MonoMethod *nm;
nm = mono_marshal_get_native_wrapper (method, TRUE, FALSE);
- cfg = mini_method_compile (nm, opt, mono_get_root_domain (), 0, part, -1);
+ cfg = mini_method_compile (nm, opt, mono_get_root_domain (), (JitFlags)0, part, -1);
}
else
- cfg = mini_method_compile (method, opt, mono_get_root_domain (), 0, part, -1);
+ cfg = mini_method_compile (method, opt, mono_get_root_domain (), (JitFlags)0, part, -1);
if ((mono_graph_options & MONO_GRAPH_CFG_SSA) && !(cfg->comp_done & MONO_COMP_SSA)) {
g_warning ("no SSA info available (use -O=deadce)");
return 1;
opt = opt_sets [i];
g_timer_start (timer);
for (j = 0; j < count; ++j) {
- cfg = mini_method_compile (method, opt, mono_get_root_domain (), 0, 0, -1);
+ cfg = mini_method_compile (method, opt, mono_get_root_domain (), (JitFlags)0, 0, -1);
mono_destroy_compile (cfg);
}
g_timer_stop (timer);
(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
method = mono_marshal_get_native_wrapper (method, TRUE, FALSE);
- cfg = mini_method_compile (method, opt, mono_get_root_domain (), 0, 0, -1);
+ cfg = mini_method_compile (method, opt, mono_get_root_domain (), (JitFlags)0, 0, -1);
mono_destroy_compile (cfg);
}
}
} else {
- cfg = mini_method_compile (method, opt, mono_get_root_domain (), 0, 0, -1);
+ cfg = mini_method_compile (method, opt, mono_get_root_domain (), (JitFlags)0, 0, -1);
mono_destroy_compile (cfg);
}
#endif
/* First the environment variable settings, to allow the command line options to override */
for (i = 0; i < array->len; i++)
- new_argv [i+1] = g_ptr_array_index (array, i);
+ new_argv [i+1] = (char *)g_ptr_array_index (array, i);
i++;
for (j = 1; j < argc; j++)
new_argv [i++] = argv [j];
int len, i, j;
len = strlen (name);
- s = g_malloc0 ((len + 1) * 2);
+ s = (char *)g_malloc0 ((len + 1) * 2);
j = 0;
for (i = 0; i < len; ++i) {
if (name [i] == '\\') {
/* Collect files */
info_list = g_slist_reverse (w->line_info);
for (l = info_list; l; l = l->next) {
- MethodLineNumberInfo *info = l->data;
+ MethodLineNumberInfo *info = (MethodLineNumberInfo *)l->data;
MonoDebugMethodInfo *minfo;
GPtrArray *source_file_list;
mono_debug_get_seq_points (minfo, NULL, &source_file_list, NULL, NULL, NULL);
for (i = 0; i < source_file_list->len; ++i) {
- MonoDebugSourceInfo *sinfo = g_ptr_array_index (source_file_list, i);
+ MonoDebugSourceInfo *sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, i);
add_line_number_file_name (w, sinfo->source_file, 0, 0);
}
}
dir_to_index = g_hash_table_new (g_str_hash, g_str_equal);
index_to_dir = g_hash_table_new (NULL, NULL);
for (i = 0; i < w->line_number_file_index; ++i) {
- char *name = g_hash_table_lookup (w->index_to_file, GUINT_TO_POINTER (i + 1));
+ char *name = (char *)g_hash_table_lookup (w->index_to_file, GUINT_TO_POINTER (i + 1));
char *copy;
int dir_index = 0;
/* Includes */
emit_section_change (w, ".debug_line", 0);
for (i = 0; i < w->line_number_dir_index; ++i) {
- char *dir = g_hash_table_lookup (index_to_dir, GUINT_TO_POINTER (i + 1));
+ char *dir = (char *)g_hash_table_lookup (index_to_dir, GUINT_TO_POINTER (i + 1));
emit_string (w, mono_dwarf_escape_path (dir));
}
/* Files */
for (i = 0; i < w->line_number_file_index; ++i) {
- char *name = g_hash_table_lookup (w->index_to_file, GUINT_TO_POINTER (i + 1));
+ char *name = (char *)g_hash_table_lookup (w->index_to_file, GUINT_TO_POINTER (i + 1));
char *basename = NULL, *dir;
int dir_index = 0;
/* Emit line number table */
for (l = info_list; l; l = l->next) {
- MethodLineNumberInfo *info = l->data;
+ MethodLineNumberInfo *info = (MethodLineNumberInfo *)l->data;
MonoDebugMethodJitInfo *dmji;
dmji = mono_debug_find_method (info->method, mono_domain_get ());
else
cache = w->class_to_die;
- return g_hash_table_lookup (cache, klass);
+ return (const char *)g_hash_table_lookup (cache, klass);
}
/* Returns the local symbol pointing to the emitted debug info */
else
cache = w->class_to_die;
- die = g_hash_table_lookup (cache, klass);
+ die = (char *)g_hash_table_lookup (cache, klass);
if (die)
return die;
if (t->byref) {
if (t->type == MONO_TYPE_VALUETYPE) {
- tdie = g_hash_table_lookup (w->class_to_pointer_die, klass);
+ tdie = (const char *)g_hash_table_lookup (w->class_to_pointer_die, klass);
}
else {
tdie = get_class_die (w, klass, FALSE);
} else {
switch (t->type) {
case MONO_TYPE_CLASS:
- tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
+ tdie = (const char *)g_hash_table_lookup (w->class_to_reference_die, klass);
//tdie = ".LDIE_OBJECT";
break;
case MONO_TYPE_ARRAY:
break;
case MONO_TYPE_GENERICINST:
if (!MONO_TYPE_ISSTRUCT (t)) {
- tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
+ tdie = (const char *)g_hash_table_lookup (w->class_to_reference_die, klass);
} else {
tdie = ".LDIE_I4";
}
case CEE_CASTCLASS:
case CEE_LDELEMA:
if (method->wrapper_type) {
- klass = data;
+ klass = (MonoClass *)data;
} else {
klass = mono_class_get_checked (method->klass->image, token, &error);
g_assert (mono_error_ok (&error)); /* FIXME error handling */
case CEE_CALL:
case CEE_CALLVIRT:
if (method->wrapper_type)
- cmethod = data;
+ cmethod = (MonoMethod *)data;
else
cmethod = mono_get_method_full (method->klass->image, token, NULL, NULL);
desc = mono_method_full_name (cmethod, TRUE);
break;
case CEE_CALLI:
if (method->wrapper_type) {
- desc = mono_signature_get_desc (data, FALSE);
+ desc = mono_signature_get_desc ((MonoMethodSignature *)data, FALSE);
res = g_strdup_printf ("<%s>", desc);
g_free (desc);
} else {
case CEE_STFLD:
case CEE_STSFLD:
if (method->wrapper_type) {
- field = data;
+ field = (MonoClassField *)data;
} else {
field = mono_field_from_token_checked (method->klass->image, token, &klass, NULL, &error);
g_assert (mono_error_ok (&error)); /* FIXME error handling */
ln_array = g_new0 (MonoDebugLineNumberEntry, debug_info->num_line_numbers);
memcpy (ln_array, debug_info->line_numbers, debug_info->num_line_numbers * sizeof (MonoDebugLineNumberEntry));
- qsort (ln_array, debug_info->num_line_numbers, sizeof (MonoDebugLineNumberEntry), (gpointer)compare_lne);
+ qsort (ln_array, debug_info->num_line_numbers, sizeof (MonoDebugLineNumberEntry), (int (*)(const void *, const void *))compare_lne);
native_to_il_offset = g_new0 (int, code_size + 1);
/* restore_contect (MonoContext *ctx) */
- start = code = mono_global_codeman_reserve (256);
+ start = code = (guint8 *)mono_global_codeman_reserve (256);
amd64_mov_reg_reg (code, AMD64_R11, AMD64_ARG_REG1, 8);
GSList *unwind_ops = NULL;
const guint kMaxCodeSize = NACL_SIZE (128, 256);
- start = code = mono_global_codeman_reserve (kMaxCodeSize);
+ start = code = (guint8 *)mono_global_codeman_reserve (kMaxCodeSize);
/* call_filter (MonoContext *ctx, unsigned long eip) */
code = start;
dummy_stack_space = 0;
#endif
- start = code = mono_global_codeman_reserve (kMaxCodeSize);
+ start = code = (guint8 *)mono_global_codeman_reserve (kMaxCodeSize);
/* The stack is unaligned on entry */
stack_size = ALIGN_TO (sizeof (MonoContext) + 64 + dummy_stack_space, MONO_ARCH_FRAME_ALIGNMENT) + 8;
for (i = 0; i < AMD64_NREG; ++i)
regs [i] = new_ctx->gregs [i];
- mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
+ mono_unwind_frame (unwind_info, unwind_info_len, (guint8 *)ji->code_start,
(guint8*)ji->code_start + ji->code_size,
- ip, epilog ? &epilog : NULL, regs, MONO_MAX_IREGS + 1,
+ (guint8 *)ip, epilog ? &epilog : NULL, regs, MONO_MAX_IREGS + 1,
save_locations, MONO_MAX_IREGS, &cfa);
for (i = 0; i < AMD64_NREG; ++i)
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
- *lmf = (gpointer)(((guint64)(*lmf)->previous_lmf) & ~7);
+ *lmf = (MonoLMF *)(((guint64)(*lmf)->previous_lmf) & ~7);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
rip = *(guint64*)((*lmf)->rsp - sizeof(mgreg_t));
}
- ji = mini_jit_info_table_find (domain, (gpointer)rip, NULL);
+ ji = mini_jit_info_table_find (domain, (char *)rip, NULL);
/*
* FIXME: ji == NULL can happen when a managed-to-native wrapper is interrupted
* in the soft debugger suspend code, since (*lmf)->rsp no longer points to the
}
}
- *lmf = (gpointer)(((guint64)(*lmf)->previous_lmf) & ~7);
+ *lmf = (MonoLMF *)(((guint64)(*lmf)->previous_lmf) & ~7);
return TRUE;
}
static void
handle_signal_exception (gpointer obj)
{
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoContext ctx;
memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
- mono_handle_exception (&ctx, obj);
+ mono_handle_exception (&ctx, (MonoObject *)obj);
mono_restore_context (&ctx);
}
* signal is disabled, and we could run arbitrary code though the debugger. So
* resume into the normal stack and do most work there if possible.
*/
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
/* Pass the ctx parameter in TLS */
mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
static void
restore_soft_guard_pages (void)
{
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
if (jit_tls->stack_ovf_guard_base)
mono_mprotect (jit_tls->stack_ovf_guard_base, jit_tls->stack_ovf_guard_size, MONO_MMAP_NONE);
}
prepare_for_guard_pages (MonoContext *mctx)
{
gpointer *sp;
- sp = (gpointer)(mctx->gregs [AMD64_RSP]);
+ sp = (gpointer *)(mctx->gregs [AMD64_RSP]);
sp -= 1;
/* the return addr */
sp [0] = (gpointer)(mctx->gregs [AMD64_RIP]);
}
static void
-altstack_handle_and_restore (MonoContext *ctx, gpointer obj, gboolean stack_ovf)
+altstack_handle_and_restore (MonoContext *ctx, MonoObject *obj, gboolean stack_ovf)
{
MonoContext mctx;
{
#if defined(MONO_ARCH_USE_SIGACTION)
MonoException *exc = NULL;
- MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)UCONTEXT_REG_RIP (sigctx), NULL);
+ MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (char *)UCONTEXT_REG_RIP (sigctx), NULL);
gpointer *sp;
int frame_size;
MonoContext *copied_ctx;
frame_size = sizeof (MonoContext) + sizeof (gpointer) * 4 + 128;
frame_size += 15;
frame_size &= ~15;
- sp = (gpointer)(UCONTEXT_REG_RSP (sigctx) & ~15);
- sp = (gpointer)((char*)sp - frame_size);
+ sp = (gpointer *)(UCONTEXT_REG_RSP (sigctx) & ~15);
+ sp = (gpointer *)((char*)sp - frame_size);
copied_ctx = (MonoContext*)(sp + 4);
/* the arguments must be aligned */
sp [-1] = (gpointer)UCONTEXT_REG_RIP (sigctx);
/* Call this to avoid initialization races */
tramps = mono_amd64_get_exception_trampolines (FALSE);
for (l = tramps; l; l = l->next) {
- MonoTrampInfo *info = l->data;
+ MonoTrampInfo *info = (MonoTrampInfo *)l->data;
mono_register_jit_icall (info->code, g_strdup (info->name), NULL, TRUE);
mono_tramp_info_register (info, NULL);
if (saved)
return (MonoContinuationRestore)saved;
- code = start = mono_global_codeman_reserve (kMaxCodeSize);
+ code = start = (guint8 *)mono_global_codeman_reserve (kMaxCodeSize);
/* the signature is: restore (MonoContinuation *cont, int state, MonoLMF **lmf_addr) */
/* cont is in AMD64_ARG_REG1 ($rcx or $rdi)
* state is in AMD64_ARG_REG2 ($rdx or $rsi)
is_template = TRUE;
desc = g_new0 (OpDesc, 1);
} else {
- desc = g_hash_table_lookup (table, str);
+ desc = (OpDesc *)g_hash_table_lookup (table, str);
if (!desc)
g_error ("Invalid opcode '%s' at line %d in %s\n", str, line, name);
if (desc->desc)
tname = p;
while (*p && isalnum (*p)) ++p;
*p++ = 0;
- tdesc = g_hash_table_lookup (template_table, tname);
+ tdesc = (OpDesc *)g_hash_table_lookup (template_table, tname);
if (!tdesc)
g_error ("Invalid template name %s at '%s' at line %d in %s\n", tname, p, line, name);
for (i = 0; i < MONO_INST_MAX; ++i) {
convert_name (const char *str)
{
int i, j, len = strlen (str);
- char *res = g_malloc (len * 2);
+ char *res = (char *)g_malloc (len * 2);
j = 0;
for (i = 0; i < len; i++) {
guint8 *data;
while (new_size <= new_offset)
new_size *= 2;
- data = g_malloc0 (new_size);
+ data = (guint8 *)g_malloc0 (new_size);
#ifdef __native_client_codegen__
/* for Native Client, fill empty space with HLT instruction */
/* instead of 00. */
create_reloc (MonoImageWriter *acfg, const char *end, const char* start, int offset)
{
BinReloc *reloc;
- reloc = mono_mempool_alloc0 (acfg->mempool, sizeof (BinReloc));
+ reloc = (BinReloc *)mono_mempool_alloc0 (acfg->mempool, sizeof (BinReloc));
reloc->val1 = mono_mempool_strdup (acfg->mempool, end);
if (strcmp (start, ".") == 0) {
reloc->val2_section = acfg->cur_section;
BinSection *section;
gsize value;
- lab = g_hash_table_lookup (acfg->labels, name);
+ lab = (BinLabel *)g_hash_table_lookup (acfg->labels, name);
if (!lab)
g_error ("Undefined label: '%s'.\n", name);
section = lab->section;
/*g_print ("sym name %s tabled to %d\n", symbol->name, symbols [i].st_name);*/
section = symbol->section;
symbols [i].st_shndx = section->parent? section->parent->shidx: section->shidx;
- lab = g_hash_table_lookup (acfg->labels, symbol->name);
+ lab = (BinLabel *)g_hash_table_lookup (acfg->labels, symbol->name);
offset = lab->offset;
if (section->parent) {
symbols [i].st_value = section->parent->virt_offset + section->cur_offset + offset;
}
if (symbol->end_label) {
- BinLabel *elab = g_hash_table_lookup (acfg->labels, symbol->end_label);
+ BinLabel *elab = (BinLabel *)g_hash_table_lookup (acfg->labels, symbol->end_label);
g_assert (elab);
symbols [i].st_size = elab->offset - lab->offset;
}
if (dynamic && !symbol->is_global)
continue;
section = symbol->section;
- lab = g_hash_table_lookup (acfg->labels, symbol->name);
+ lab = (BinLabel *)g_hash_table_lookup (acfg->labels, symbol->name);
offset = lab->offset;
if (section->parent) {
symbols [i].st_value = sheaders [section->parent->shidx].sh_addr + section->cur_offset + offset;
if (!acfg->fp) {
acfg->out_buf_size = file_offset + sizeof (secth);
- acfg->out_buf = g_malloc (acfg->out_buf_size);
+ acfg->out_buf = (guint8 *)g_malloc (acfg->out_buf_size);
}
bin_writer_fwrite (acfg, &header, sizeof (header), 1);
* JIT code still uses the left and right fields, so it has to stay.
*/
#define MONO_INST_NEW(cfg,dest,op) do { \
- (dest) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); \
+ (dest) = (MonoInst *)mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->inst_c0 = (dest)->inst_c1 = 0; \
(dest)->next = (dest)->prev = NULL; \
(dest)->opcode = (op); \
#define NEW_AOTCONST(cfg,dest,patch_type,cons) do { \
MONO_INST_NEW ((cfg), (dest), cfg->compile_aot ? OP_AOTCONST : OP_PCONST); \
(dest)->inst_p0 = (cons); \
- (dest)->inst_i1 = (gpointer)(patch_type); \
+ (dest)->inst_i1 = (MonoInst *)(patch_type); \
(dest)->type = STACK_PTR; \
(dest)->dreg = alloc_dreg ((cfg), STACK_PTR); \
} while (0)
type_to_eval_stack_type ((cfg), (vartype), (dest)); \
(dest)->klass = var->klass; \
(dest)->sreg1 = var->dreg; \
- (dest)->dreg = alloc_dreg ((cfg), (dest)->type); \
+ (dest)->dreg = alloc_dreg ((cfg), (MonoStackType)(dest)->type); \
if ((dest)->opcode == OP_VMOVE) (dest)->klass = mono_class_from_mono_type ((vartype)); \
} while (0)
(dest)->type = STACK_MP; \
(dest)->klass = cfg->ret->klass; \
(dest)->sreg1 = cfg->vret_addr->dreg; \
- (dest)->dreg = alloc_dreg ((cfg), (dest)->type); \
+ (dest)->dreg = alloc_dreg ((cfg), (MonoStackType)(dest)->type); \
} while (0)
#define NEW_ARGLOADA(cfg,dest,num) NEW_VARLOADA ((cfg), (dest), arg_array [(num)], param_types [(num)])
#define NEW_LOAD_MEMBASE_TYPE(cfg,dest,ltype,base,offset) do { \
NEW_LOAD_MEMBASE ((cfg), (dest), mono_type_to_load_membase ((cfg), (ltype)), 0, (base), (offset)); \
type_to_eval_stack_type ((cfg), (ltype), (dest)); \
- (dest)->dreg = alloc_dreg ((cfg), (dest)->type); \
+ (dest)->dreg = alloc_dreg ((cfg), (MonoStackType)(dest)->type); \
} while (0)
#define NEW_STORE_MEMBASE_TYPE(cfg,dest,ltype,base,offset,sr) do { \
* block_num: unique ID assigned at bblock creation
*/
#define NEW_BBLOCK(cfg,bblock) do { \
- (bblock) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); \
+ (bblock) = (MonoBasicBlock *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); \
(bblock)->block_num = cfg->num_bblocks++; \
} while (0)
MONO_ADD_INS ((cfg)->cbb, ins); \
MONO_START_BB ((cfg), falsebb); \
} else { \
- ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
+ ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
ins->inst_true_bb = (truebb); \
ins->inst_false_bb = NULL; \
mono_link_bblock ((cfg), (cfg)->cbb, (truebb)); \
#define MONO_EMIT_NEW_BRANCH_BLOCK2(cfg,op,truebb,falsebb) do { \
MonoInst *ins; \
MONO_INST_NEW ((cfg), (ins), (op)); \
- ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
+ ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
ins->inst_true_bb = (truebb); \
ins->inst_false_bb = (falsebb); \
mono_link_bblock ((cfg), (cfg)->cbb, (truebb)); \
va_start (ap, cm);
- lengths = alloca (sizeof (uintptr_t) * pcount);
+ lengths = (uintptr_t *)alloca (sizeof (uintptr_t) * pcount);
for (i = 0; i < pcount; ++i)
lengths [i] = d = va_arg(ap, int);
if (rank == pcount) {
/* Only lengths provided. */
if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
- lower_bounds = alloca (sizeof (intptr_t) * rank);
+ lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
memset (lower_bounds, 0, sizeof (intptr_t) * rank);
} else {
lower_bounds = NULL;
g_assert (rank == pcount);
if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
- lower_bounds = alloca (sizeof (intptr_t) * rank);
+ lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
memset (lower_bounds, 0, sizeof (intptr_t) * rank);
} else {
lower_bounds = NULL;
g_assert (rank == pcount);
if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
- lower_bounds = alloca (sizeof (intptr_t) * rank);
+ lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
memset (lower_bounds, 0, sizeof (intptr_t) * rank);
} else {
lower_bounds = NULL;
g_assert (rank == pcount);
if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
- lower_bounds = alloca (sizeof (intptr_t) * rank);
+ lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
memset (lower_bounds, 0, sizeof (intptr_t) * rank);
} else {
lower_bounds = NULL;
g_assert (rank == pcount);
if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
- lower_bounds = alloca (sizeof (intptr_t) * rank);
+ lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
memset (lower_bounds, 0, sizeof (intptr_t) * rank);
} else {
lower_bounds = NULL;
MonoClass *oklass;
if (mini_get_debug_options ()->better_cast_details) {
- jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
jit_tls->class_cast_from = NULL;
}
gpointer cached_vtable, obj_vtable;
if (mini_get_debug_options ()->better_cast_details) {
- jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
jit_tls->class_cast_from = NULL;
}
/*
* The exact compiled method might not be shared so it doesn't have an rgctx arg.
*/
- ji = mini_jit_info_table_find (mono_domain_get (), compiled_method, NULL);
+ ji = mini_jit_info_table_find (mono_domain_get (), (char *)compiled_method, NULL);
if (!ji || (ji && ji->has_generic_jit_info)) {
if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED && m->klass->rank && strstr (m->name, "System.Collections.Generic"))
m = mono_aot_get_array_helper_from_wrapper (m);
gpointer mono_fill_method_rgctx (MonoMethodRuntimeGenericContext *mrgctx, int index);
-gpointer mono_resolve_iface_call (MonoObject *this, int imt_slot, MonoMethod *imt_method, gpointer *out_rgctx_arg);
+gpointer mono_resolve_iface_call (MonoObject *this_obj, int imt_slot, MonoMethod *imt_method, gpointer *out_rgctx_arg);
-gpointer mono_resolve_vcall (MonoObject *this, int slot, MonoMethod *imt_method);
+gpointer mono_resolve_vcall (MonoObject *this_obj, int slot, MonoMethod *imt_method);
void mono_init_delegate (MonoDelegate *del, MonoObject *target, MonoMethod *method);
return g_list_prepend (NULL, mv);
for (l = list; l; l = l->next) {
- MonoMethodVar *v1 = l->data;
+ MonoMethodVar *v1 = (MonoMethodVar *)l->data;
if (sort_type == 2) {
if (mv->spill_costs >= v1->spill_costs) {
/* linear scan */
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
#ifdef DEBUG_LSCAN
printf ("START %2d %08x %08x\n", vmv->idx, vmv->range.first_use.abs_pos,
n_regvars = 0;
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
if (vmv->reg >= 0) {
if ((gains [vmv->reg] > mono_arch_regalloc_cost (cfg, vmv)) && (cfg->varinfo [vmv->idx]->opcode != OP_REGVAR)) {
/* Compute used regs */
used_regs = 0;
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
if (vmv->reg >= 0)
used_regs |= 1LL << vmv->reg;
int n_regs, n_regvars, i;
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
LSCAN_DEBUG (printf ("VAR R%d %08x %08x C%d\n", cfg->varinfo [vmv->idx]->dreg, vmv->range.first_use.abs_pos,
vmv->range.last_use.abs_pos, vmv->spill_costs));
}
inactive = NULL;
while (unhandled) {
- MonoMethodVar *current = unhandled->data;
+ MonoMethodVar *current = (MonoMethodVar *)unhandled->data;
int pos, reg, max_free_pos;
gboolean changed;
/* Do the actual register assignment */
n_regvars = 0;
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
if (vmv->reg >= 0) {
int reg_index = vmv->reg;
/* Compute used regs */
used_regs = 0;
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
if (vmv->reg >= 0)
used_regs |= 1LL << vmv->reg;
static inline MonoBitSet*
mono_bitset_mp_new (MonoMemPool *mp, guint32 size, guint32 max_size)
{
- guint8 *mem = mono_mempool_alloc0 (mp, size);
+ guint8 *mem = (guint8 *)mono_mempool_alloc0 (mp, size);
return mono_bitset_mem_new (mem, max_size, MONO_BITSET_DONT_FREE);
}
static inline MonoBitSet*
mono_bitset_mp_new_noinit (MonoMemPool *mp, guint32 size, guint32 max_size)
{
- guint8 *mem = mono_mempool_alloc (mp, size);
+ guint8 *mem = (guint8 *)mono_mempool_alloc (mp, size);
return mono_bitset_mem_new (mem, max_size, MONO_BITSET_DONT_FREE);
}
* Determine which clauses are outer try clauses, i.e. they are not contained in any
* other non-try clause.
*/
- outer_try = mono_mempool_alloc0 (cfg->mempool, sizeof (gboolean) * header->num_clauses);
+ outer_try = (gboolean *)mono_mempool_alloc0 (cfg->mempool, sizeof (gboolean) * header->num_clauses);
for (i = 0; i < header->num_clauses; ++i)
outer_try [i] = TRUE;
/* Iterate over the clauses backward, so outer clauses come first */
continue;
if (ins->opcode == OP_LDADDR) {
- MonoInst *var = ins->inst_p0;
+ MonoInst *var = (MonoInst *)ins->inst_p0;
int idx = var->inst_c0;
MonoMethodVar *vi = MONO_VARINFO (cfg, idx);
next_range->from = from;
} else {
/* Insert it */
- new_range = mono_mempool_alloc (cfg->mempool, sizeof (MonoLiveRange2));
+ new_range = (MonoLiveRange2 *)mono_mempool_alloc (cfg->mempool, sizeof (MonoLiveRange2));
new_range->from = from;
new_range->to = to;
new_range->next = NULL;
g_assert (pos > interval->range->from && pos <= interval->last_range->to);
- *i1 = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoLiveInterval));
- *i2 = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoLiveInterval));
+ *i1 = (MonoLiveInterval *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoLiveInterval));
+ *i2 = (MonoLiveInterval *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoLiveInterval));
for (r = interval->range; r; r = r->next) {
if (pos > r->to) {
last_use = g_new0 (gint32, max_vars);
reverse_len = 1024;
- reverse = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * reverse_len);
+ reverse = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * reverse_len);
for (idx = 0; idx < max_vars; ++idx) {
MonoMethodVar *vi = MONO_VARINFO (cfg, idx);
- vi->interval = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoLiveInterval));
+ vi->interval = (MonoLiveInterval *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoLiveInterval));
}
/*
for (nins = 0, pos = block_from, ins = bb->code; ins; ins = ins->next, ++nins, ++pos) {
if (nins >= reverse_len) {
int new_reverse_len = reverse_len * 2;
- MonoInst **new_reverse = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * new_reverse_len);
+ MonoInst **new_reverse = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * new_reverse_len);
memcpy (new_reverse, reverse, sizeof (MonoInst*) * reverse_len);
reverse = new_reverse;
reverse_len = new_reverse_len;
/* Add it to the last callsite */
g_assert (*callsites);
- last = (*callsites)->data;
+ last = (GCCallSite *)(*callsites)->data;
last->param_slots = g_slist_prepend_mempool (cfg->mempool, last->param_slots, ins);
} else if (ins->flags & MONO_INST_GC_CALLSITE) {
- GCCallSite *callsite = mono_mempool_alloc0 (cfg->mempool, sizeof (GCCallSite));
+ GCCallSite *callsite = (GCCallSite *)mono_mempool_alloc0 (cfg->mempool, sizeof (GCCallSite));
int i;
LIVENESS_DEBUG (printf ("\t%x: ", ins->backend.pc_offset); mono_print_ins (ins));
LIVENESS_DEBUG (printf ("\t\tlive: "));
callsite->bb = bb;
- callsite->liveness = mono_mempool_alloc0 (cfg->mempool, ALIGN_TO (cfg->num_varinfo, 8) / 8);
+ callsite->liveness = (guint8 *)mono_mempool_alloc0 (cfg->mempool, ALIGN_TO (cfg->num_varinfo, 8) / 8);
callsite->pc_offset = ins->backend.pc_offset;
for (i = 0; i < cfg->num_varinfo; ++i) {
if (last_use [i] != 0) {
}
reverse_len = 1024;
- reverse = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * reverse_len);
+ reverse = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * reverse_len);
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
MonoInst *ins;
for (nins = 0, pos = block_from, ins = bb->code; ins; ins = ins->next, ++nins, ++pos) {
if (nins >= reverse_len) {
int new_reverse_len = reverse_len * 2;
- MonoInst **new_reverse = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * new_reverse_len);
+ MonoInst **new_reverse = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * new_reverse_len);
memcpy (new_reverse, reverse, sizeof (MonoInst*) * reverse_len);
reverse = new_reverse;
reverse_len = new_reverse_len;
restart:
max = cfg->next_vreg;
- defs = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * (cfg->next_vreg + 1));
- def_index = mono_mempool_alloc (cfg->mempool, sizeof (guint32) * (cfg->next_vreg + 1));
+ defs = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * (cfg->next_vreg + 1));
+ def_index = (gint32 *)mono_mempool_alloc (cfg->mempool, sizeof (guint32) * (cfg->next_vreg + 1));
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
MonoInst *ins;
/* FIXME: Optimize this */
if (ins->opcode == OP_LDADDR) {
- MonoInst *var = ins->inst_p0;
+ MonoInst *var = (MonoInst *)ins->inst_p0;
defs [var->dreg] = NULL;
/*
CHECK_TYPE (ins); \
/* Have to insert a widening op */ \
add_widen_op (cfg, ins, &sp [0], &sp [1]); \
- ins->dreg = alloc_dreg ((cfg), (ins)->type); \
+ ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
MONO_ADD_INS ((cfg)->cbb, (ins)); \
*sp++ = mono_decompose_opcode ((cfg), (ins)); \
} while (0)
ins->sreg1 = sp [0]->dreg; \
type_from_op (cfg, ins, sp [0], NULL); \
CHECK_TYPE (ins); \
- (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
+ (ins)->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
MONO_ADD_INS ((cfg)->cbb, (ins)); \
*sp++ = mono_decompose_opcode (cfg, ins); \
} while (0)
CHECK_TYPE (cmp); \
add_widen_op (cfg, cmp, &sp [0], &sp [1]); \
type_from_op (cfg, ins, sp [0], sp [1]); \
- ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
+ ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
GET_BBLOCK (cfg, tblock, target); \
link_bblock (cfg, cfg->cbb, tblock); \
ins->inst_true_bb = tblock; \
}
}
if (!found) {
- newa = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
+ newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
for (i = 0; i < from->out_count; ++i) {
newa [i] = from->out_bb [i];
}
}
}
if (!found) {
- newa = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
+ newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
for (i = 0; i < to->in_count; ++i) {
newa [i] = to->in_bb [i];
}
{
MonoInst *var;
- var = g_hash_table_lookup (cfg->spvars, GINT_TO_POINTER (region));
+ var = (MonoInst *)g_hash_table_lookup (cfg->spvars, GINT_TO_POINTER (region));
if (var)
return;
MonoInst *
mono_find_exvar_for_offset (MonoCompile *cfg, int offset)
{
- return g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
+ return (MonoInst *)g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
}
static MonoInst*
{
MonoInst *var;
- var = g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
+ var = (MonoInst *)g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
if (var)
return var;
* table == 0 means this is a reference made from a wrapper.
*/
if (cfg->compile_aot && !cfg->generic_context && (mono_metadata_token_table (token) > 0)) {
- MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
+ MonoJumpInfoToken *jump_info_token = (MonoJumpInfoToken *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
jump_info_token->image = image;
jump_info_token->token = token;
g_hash_table_insert (cfg->token_info_hash, key, jump_info_token);
}
//printf ("\n");
if (!found) {
- bb->out_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * count);
+ bb->out_stack = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * count);
for (i = 0; i < count; ++i) {
/*
* try to reuse temps already allocated for this purpouse, if they occupy the same
}
static void
-emit_tls_set (MonoCompile *cfg, int sreg1, int tls_key)
+emit_tls_set (MonoCompile *cfg, int sreg1, MonoTlsKey tls_key)
{
MonoInst *ins, *c;
static MonoJumpInfo *
mono_patch_info_new (MonoMemPool *mp, int ip, MonoJumpInfoType type, gconstpointer target)
{
- MonoJumpInfo *ji = mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
+ MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
ji->ip.i = ip;
ji->type = type;
inline static MonoCallInst *
mono_emit_call_args (MonoCompile *cfg, MonoMethodSignature *sig,
- MonoInst **args, int calli, int virtual, int tail, int rgctx, int unbox_trampoline)
+ MonoInst **args, int calli, int virtual_, int tail, int rgctx, int unbox_trampoline)
{
MonoType *sig_ret;
MonoCallInst *call;
MONO_INST_NEW_CALL (cfg, call, OP_TAILCALL);
} else
- MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (cfg, sig->ret, calli, virtual));
+ MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (cfg, sig->ret, calli, virtual_));
call->args = args;
call->signature = sig;
call->vret_var = loada;
} else if (!MONO_TYPE_IS_VOID (sig_ret))
- call->inst.dreg = alloc_dreg (cfg, call->inst.type);
+ call->inst.dreg = alloc_dreg (cfg, (MonoStackType)call->inst.type);
#ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
if (COMPILE_SOFT_FLOAT (cfg)) {
#ifndef DISABLE_REMOTING
gboolean might_be_remote = FALSE;
#endif
- gboolean virtual = this_ins != NULL;
+ gboolean virtual_ = this_ins != NULL;
gboolean enable_for_aot = TRUE;
int context_used;
MonoCallInst *call;
}
#endif
- if (cfg->llvm_only && !call_target && virtual && (method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
+ if (cfg->llvm_only && !call_target && virtual_ && (method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
// FIXME: Vcall optimizations below
MonoInst *icall_args [16];
MonoInst *ins;
need_unbox_trampoline = method->klass == mono_defaults.object_class || (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
- call = mono_emit_call_args (cfg, sig, args, FALSE, virtual, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
+ call = mono_emit_call_args (cfg, sig, args, FALSE, virtual_, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
#ifndef DISABLE_REMOTING
if (might_be_remote)
call->inst.inst_left = this_ins;
call->tail_call = tail;
- if (virtual) {
+ if (virtual_) {
int vtable_reg, slot_reg, this_reg;
int offset;
static MonoJumpInfoRgctxEntry *
mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
{
- MonoJumpInfoRgctxEntry *res = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
+ MonoJumpInfoRgctxEntry *res = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
res->method = method;
res->in_mrgctx = in_mrgctx;
- res->data = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
+ res->data = (MonoJumpInfo *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
res->data->type = patch_type;
res->data->data.target = patch_data;
res->info_type = info_type;
MonoJumpInfoRgctxEntry *entry;
MonoInst *rgctx;
- call_info = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
+ call_info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
call_info->sig = sig;
call_info->method = cmethod;
MonoJumpInfoRgctxEntry *entry;
MonoInst *rgctx;
- info = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
+ info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
info->klass = klass;
info->method = virt_method;
get_gsharedvt_info_slot (MonoCompile *cfg, gpointer data, MonoRgctxInfoType rgctx_type)
{
MonoGSharedVtMethodInfo *info = cfg->gsharedvt_info;
- MonoRuntimeGenericContextInfoTemplate *template;
+ MonoRuntimeGenericContextInfoTemplate *template_;
int i, idx;
g_assert (info);
MonoRuntimeGenericContextInfoTemplate *new_entries;
int new_count_entries = info->count_entries ? info->count_entries * 2 : 16;
- new_entries = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
+ new_entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
info->entries = new_entries;
}
idx = info->num_entries;
- template = &info->entries [idx];
- template->info_type = rgctx_type;
- template->data = data;
+ template_ = &info->entries [idx];
+ template_->info_type = rgctx_type;
+ template_->data = data;
info->num_entries ++;
MonoInst *unbox_call;
MonoMethodSignature *unbox_sig;
- unbox_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
+ unbox_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
unbox_sig->ret = &klass->byval_arg;
unbox_sig->param_count = 1;
unbox_sig->params [0] = &mono_defaults.object_class->byval_arg;
if (context_used) {
MonoInst *data;
- int rgctx_info;
+ MonoRgctxInfoType rgctx_info;
MonoInst *iargs [2];
gboolean known_instance_size = !mini_is_gsharedvt_klass (klass);
* klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
* construct that method at JIT time, so have to do things by hand.
*/
- box_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
+ box_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
box_sig->ret = &mono_defaults.object_class->byval_arg;
box_sig->param_count = 1;
box_sig->params [0] = &klass->byval_arg;
}
{
- MonoInst *load, *and, *cmp, *ceq;
+ MonoInst *load, *and_, *cmp, *ceq;
int enum_reg = is_i4 ? alloc_ireg (cfg) : alloc_lreg (cfg);
int and_reg = is_i4 ? alloc_ireg (cfg) : alloc_lreg (cfg);
int dest_reg = alloc_ireg (cfg);
EMIT_NEW_LOAD_MEMBASE (cfg, load, load_opc, enum_reg, enum_this->dreg, 0);
- EMIT_NEW_BIALU (cfg, and, is_i4 ? OP_IAND : OP_LAND, and_reg, enum_reg, enum_flag->dreg);
+ EMIT_NEW_BIALU (cfg, and_, is_i4 ? OP_IAND : OP_LAND, and_reg, enum_reg, enum_flag->dreg);
EMIT_NEW_BIALU (cfg, cmp, is_i4 ? OP_ICOMPARE : OP_LCOMPARE, -1, and_reg, enum_flag->dreg);
EMIT_NEW_UNALU (cfg, ceq, is_i4 ? OP_ICEQ : OP_LCEQ, dest_reg, -1);
if (!is_i4) {
load = mono_decompose_opcode (cfg, load);
- and = mono_decompose_opcode (cfg, and);
+ and_ = mono_decompose_opcode (cfg, and_);
cmp = mono_decompose_opcode (cfg, cmp);
ceq = mono_decompose_opcode (cfg, ceq);
}
* Returns NULL and set the cfg exception on error.
*/
static G_GNUC_UNUSED MonoInst*
-handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used, gboolean virtual)
+handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used, gboolean virtual_)
{
MonoInst *ptr;
int dreg;
MonoDomain *domain;
guint8 **code_slot;
- if (virtual && !cfg->llvm_only) {
+ if (virtual_ && !cfg->llvm_only) {
MonoMethod *invoke = mono_get_delegate_invoke (klass);
g_assert (invoke);
args [0] = obj;
args [1] = target;
args [2] = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD);
- mono_emit_jit_icall (cfg, virtual ? mono_init_delegate_virtual : mono_init_delegate, args);
+ mono_emit_jit_icall (cfg, virtual_ ? mono_init_delegate_virtual : mono_init_delegate, args);
return obj;
}
mono_domain_lock (domain);
if (!domain_jit_info (domain)->method_code_hash)
domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL);
- code_slot = g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
+ code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
if (!code_slot) {
- code_slot = mono_domain_alloc0 (domain, sizeof (gpointer));
+ code_slot = (guint8 **)mono_domain_alloc0 (domain, sizeof (gpointer));
g_hash_table_insert (domain_jit_info (domain)->method_code_hash, method, code_slot);
}
mono_domain_unlock (domain);
if (cfg->compile_aot) {
MonoDelegateClassMethodPair *del_tramp;
- del_tramp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
+ del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
del_tramp->klass = klass;
del_tramp->method = context_used ? NULL : method;
- del_tramp->is_virtual = virtual;
+ del_tramp->is_virtual = virtual_;
EMIT_NEW_AOTCONST (cfg, tramp_ins, MONO_PATCH_INFO_DELEGATE_TRAMPOLINE, del_tramp);
} else {
- if (virtual)
+ if (virtual_)
trampoline = mono_create_delegate_virtual_trampoline (cfg->domain, klass, context_used ? NULL : method);
else
trampoline = mono_create_delegate_trampoline_info (cfg->domain, klass, context_used ? NULL : method);
}
/* Set invoke_impl field */
- if (virtual) {
+ if (virtual_) {
MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
} else {
dreg = alloc_preg (cfg);
}
dreg = alloc_preg (cfg);
- MONO_EMIT_NEW_ICONST (cfg, dreg, virtual ? 1 : 0);
+ MONO_EMIT_NEW_ICONST (cfg, dreg, virtual_ ? 1 : 0);
MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_is_virtual), dreg);
/* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
cfg->disable_llvm = TRUE;
if (args [0]->opcode == OP_GOT_ENTRY) {
- pi = args [0]->inst_p1;
+ pi = (MonoInst *)args [0]->inst_p1;
g_assert (pi->opcode == OP_PATCH_INFO);
g_assert (GPOINTER_TO_INT (pi->inst_p1) == MONO_PATCH_INFO_LDSTR);
- ji = pi->inst_p0;
+ ji = (MonoJumpInfoToken *)pi->inst_p0;
} else {
g_assert (GPOINTER_TO_INT (args [0]->inst_p1) == MONO_PATCH_INFO_LDSTR);
- ji = args [0]->inst_p0;
+ ji = (MonoJumpInfoToken *)args [0]->inst_p0;
}
NULLIFY_INS (args [0]);
MonoInst *var = cfg->locals [local];
if (COMPILE_SOFT_FLOAT (cfg)) {
MonoInst *store;
- int reg = alloc_dreg (cfg, var->type);
+ int reg = alloc_dreg (cfg, (MonoStackType)var->type);
emit_init_rvar (cfg, reg, type);
EMIT_NEW_LOCSTORE (cfg, store, local, cfg->cbb->last_ins);
} else {
guint32 prev_cil_offset_to_bb_len;
MonoMethod *prev_current_method;
MonoGenericContext *prev_generic_context;
- gboolean ret_var_set, prev_ret_var_set, prev_disable_inline, virtual = FALSE;
+ gboolean ret_var_set, prev_ret_var_set, prev_disable_inline, virtual_ = FALSE;
g_assert (cfg->exception_type == MONO_EXCEPTION_NONE);
}
prev_locals = cfg->locals;
- cfg->locals = mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
+ cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
for (i = 0; i < cheader->num_locals; ++i)
cfg->locals [i] = mono_compile_create_var (cfg, cheader->locals [i], OP_LOCAL);
prev_disable_inline = cfg->disable_inline;
if (ip && *ip == CEE_CALLVIRT && !(cmethod->flags & METHOD_ATTRIBUTE_STATIC))
- virtual = TRUE;
+ virtual_ = TRUE;
- costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, sp, real_offset, virtual);
+ costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, sp, real_offset, virtual_);
ret_var_set = cfg->ret_var_set;
MonoMethod *method;
if (m->wrapper_type != MONO_WRAPPER_NONE) {
- method = mono_method_get_wrapper_data (m, token);
+ method = (MonoMethod *)mono_method_get_wrapper_data (m, token);
if (context) {
MonoError error;
method = mono_class_inflate_generic_method_checked (method, context, &error);
MonoClass *klass;
if (method->wrapper_type != MONO_WRAPPER_NONE) {
- klass = mono_method_get_wrapper_data (method, token);
+ klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
if (context)
klass = mono_class_inflate_generic_class (klass, context);
} else {
/*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
/* for aot code we do the lookup on load */
if (aot && data_ptr)
- return GUINT_TO_POINTER (rva);
+ return (const char *)GUINT_TO_POINTER (rva);
} else {
/*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
g_assert (!aot);
MonoMethodSignature *res;
int i;
- res = g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
+ res = (MonoMethodSignature *)g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
memcpy (res, sig, MONO_SIZEOF_METHOD_SIGNATURE);
res->param_count = sig->param_count + 1;
for (i = 0; i < sig->param_count; ++i)
cfg->real_offset = inline_offset;
}
- cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
+ cfg->cil_offset_to_bb = (MonoBasicBlock **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
cfg->cil_offset_to_bb_len = header->code_size;
cfg->current_method = method;
if (cfg->verbose_level > 2)
printf ("method to IR %s\n", mono_method_full_name (method, TRUE));
- param_types = mono_mempool_alloc (cfg->mempool, sizeof (MonoType*) * num_args);
+ param_types = (MonoType **)mono_mempool_alloc (cfg->mempool, sizeof (MonoType*) * num_args);
if (sig->hasthis)
param_types [0] = method->klass->valuetype?&method->klass->this_arg:&method->klass->byval_arg;
for (n = 0; n < sig->param_count; ++n)
/* mostly like handle_stack_args (), but just sets the input args */
/* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
tblock->in_scount = 1;
- tblock->in_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
+ tblock->in_stack = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
cfg->cbb = tblock;
tblock->flags |= BB_EXCEPTION_HANDLER;
tblock->real_offset = clause->data.filter_offset;
tblock->in_scount = 1;
- tblock->in_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
+ tblock->in_stack = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
/* The filter block shares the exvar with the handler block */
tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
MONO_INST_NEW (cfg, ins, OP_START_HANDLER);
MonoInst *var, *locals_var;
int dreg;
- info = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
+ info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
info->method = cfg->method;
info->count_entries = 16;
- info->entries = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
+ info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
cfg->gsharedvt_info = info;
var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
}
/* we use a spare stack slot in SWITCH and NEWOBJ and others */
- stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
+ stack_start = sp = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
ins_flag = 0;
start_new_bblock = 0;
#endif
/* FIXME: we should really allocate this only late in the compilation process */
- f = mono_domain_alloc (cfg->domain, sizeof (float));
+ f = (float *)mono_domain_alloc (cfg->domain, sizeof (float));
CHECK_OPSIZE (5);
CHECK_STACK_OVF (1);
#endif
/* FIXME: we should really allocate this only late in the compilation process */
- d = mono_domain_alloc (cfg->domain, sizeof (double));
+ d = (double *)mono_domain_alloc (cfg->domain, sizeof (double));
CHECK_OPSIZE (9);
CHECK_STACK_OVF (1);
if (cfg->llvm_only) {
MonoInst **args;
- args = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
+ args = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
for (i = 0; i < n; ++i)
EMIT_NEW_ARGLOAD (cfg, args [i], i);
ins = mono_emit_method_call_full (cfg, cmethod, fsig, TRUE, args, NULL, NULL, NULL);
call->method = cmethod;
call->tail_call = TRUE;
call->signature = mono_method_signature (cmethod);
- call->args = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
+ call->args = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
call->inst.inst_p0 = cmethod;
for (i = 0; i < n; ++i)
EMIT_NEW_ARGLOAD (cfg, call->args [i], i);
CHECK_STACK (n);
- //g_assert (!virtual || fsig->hasthis);
+ //g_assert (!virtual_ || fsig->hasthis);
sp -= n;
INLINE_FAILURE ("indirect call");
if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
- int info_type;
+ MonoJumpInfoType info_type;
gpointer info_data;
/*
* with the contents of the aotconst as the patch info.
*/
if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST) {
- info_type = addr->inst_c1;
+ info_type = (MonoJumpInfoType)addr->inst_c1;
info_data = addr->inst_p0;
} else {
- info_type = addr->inst_right->inst_c1;
+ info_type = (MonoJumpInfoType)addr->inst_right->inst_c1;
info_data = addr->inst_right->inst_left;
}
MonoInst *addr = NULL;
MonoMethodSignature *fsig = NULL;
int array_rank = 0;
- int virtual = *ip == CEE_CALLVIRT;
+ int virtual_ = *ip == CEE_CALLVIRT;
gboolean pass_imt_from_rgctx = FALSE;
MonoInst *imt_arg = NULL;
MonoInst *keep_this_alive = NULL;
if (mono_security_core_clr_enabled ())
ensure_method_is_allowed_to_call_method (cfg, method, cil_method);
- if (!virtual && (cmethod->flags & METHOD_ATTRIBUTE_ABSTRACT))
+ if (!virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_ABSTRACT))
/* MS.NET seems to silently convert this to a callvirt */
- virtual = 1;
+ virtual_ = 1;
{
/*
*/
const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
const int expected_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL;
- if (!virtual && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
- virtual = 1;
+ if (!virtual_ && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
+ virtual_ = 1;
}
if (!cmethod->klass->inited)
CHECK_STACK (n);
- //g_assert (!virtual || fsig->hasthis);
+ //g_assert (!virtual_ || fsig->hasthis);
sp -= n;
CHECK_CFG_EXCEPTION;
}
}
- virtual = 0;
+ virtual_ = 0;
}
constrained_class = NULL;
}
if ((!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
MONO_METHOD_IS_FINAL (cmethod)) &&
!mono_class_is_marshalbyref (cmethod->klass)) {
- if (virtual)
+ if (virtual_)
check_this = TRUE;
- virtual = 0;
+ virtual_ = 0;
}
}
MONO_EMIT_NEW_CHECK_THIS (cfg, sp [0]->dreg);
/* Calling virtual generic methods */
- if (virtual && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) &&
+ if (virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) &&
!(MONO_METHOD_IS_FINAL (cmethod) &&
cmethod->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) &&
fsig->generic_param_count &&
/* Inlining */
if ((cfg->opt & MONO_OPT_INLINE) &&
- (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
+ (!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
mono_method_check_inlining (cfg, cmethod)) {
int costs;
gboolean always = FALSE;
!(cmethod->klass->rank && cmethod->klass->byval_arg.type != MONO_TYPE_SZARRAY)) {
MonoRgctxInfoType info_type;
- if (virtual) {
+ if (virtual_) {
//if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)
//GSHAREDVT_FAILURE (*ip);
// disable for possible remoting calls
if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
keep_this_alive = sp [0];
- if (virtual && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL))
+ if (virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL))
info_type = MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT;
else
info_type = MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE;
if (context_used && !imt_arg && !array_rank && !delegate_invoke &&
(!mono_method_is_generic_sharable_full (cmethod, TRUE, FALSE, FALSE) ||
!mono_class_generic_sharing_enabled (cmethod->klass)) &&
- (!virtual || MONO_METHOD_IS_FINAL (cmethod) ||
+ (!virtual_ || MONO_METHOD_IS_FINAL (cmethod) ||
!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL))) {
INLINE_FAILURE ("gshared");
goto call_end;
}
- ins = mini_redirect_call (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL);
+ ins = mini_redirect_call (cfg, cmethod, fsig, sp, virtual_ ? sp [0] : NULL);
if (ins)
goto call_end;
* So we make resolve_iface_call return the rgctx, and do two calls with different signatures
* based on whenever there is an rgctx or not.
*/
- if (cfg->llvm_only && virtual && cmethod && (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
+ if (cfg->llvm_only && virtual_ && cmethod && (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
MonoInst *args_buf [16], *icall_args [16];
MonoInst **args;
MonoBasicBlock *rgctx_bb, *end_bb;
if (fsig->param_count + 2 < 16)
args = args_buf;
else
- args = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (fsig->param_count + 2));
+ args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (fsig->param_count + 2));
args [0] = sp [0];
for (i = 0; i < fsig->param_count; ++i)
args [i + 1] = sp [i + 1];
/* Common call */
INLINE_FAILURE ("call");
- ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, virtual ? sp [0] : NULL,
+ ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, virtual_ ? sp [0] : NULL,
imt_arg, vtable_arg);
if (tail_call && !cfg->llvm_only) {
MONO_INST_NEW (cfg, ins, is_true ? CEE_BNE_UN : CEE_BEQ);
type_from_op (cfg, ins, sp [0], NULL);
MONO_ADD_INS (cfg->cbb, ins);
- ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);
+ ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);
GET_BBLOCK (cfg, tblock, target);
ins->inst_true_bb = tblock;
GET_BBLOCK (cfg, tblock, ip);
GET_BBLOCK (cfg, default_bblock, target);
default_bblock->flags |= BB_INDIRECT_JUMP_TARGET;
- targets = mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * n);
+ targets = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * n);
for (i = 0; i < n; ++i) {
GET_BBLOCK (cfg, tblock, target + (gint32)read32(ip));
targets [i] = tblock;
for (i = 0; i < n; ++i)
link_bblock (cfg, cfg->cbb, targets [i]);
- table = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
+ table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
table->table = targets;
table->table_size = n;
ins->sreg1 = src1->dreg;
ins->inst_p0 = table;
ins->inst_many_bb = targets;
- ins->klass = GUINT_TO_POINTER (n);
+ ins->klass = (MonoClass *)GUINT_TO_POINTER (n);
MONO_ADD_INS (cfg->cbb, ins);
} else {
if (sizeof (gpointer) == 8)
ins->sreg2 = sp [1]->dreg;
type_from_op (cfg, ins, sp [0], sp [1]);
CHECK_TYPE (ins);
- ins->dreg = alloc_dreg ((cfg), (ins)->type);
+ ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type);
/* Use the immediate opcodes if possible */
if ((sp [1]->opcode == OP_ICONST) && mono_arch_is_inst_imm (sp [1]->inst_c0)) {
type_from_op (cfg, ins, sp [0], sp [1]);
CHECK_TYPE (ins);
add_widen_op (cfg, ins, &sp [0], &sp [1]);
- ins->dreg = alloc_dreg ((cfg), (ins)->type);
+ ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type);
/* FIXME: Pass opcode to is_inst_imm */
}
else if (method->wrapper_type != MONO_WRAPPER_NONE) {
MonoInst *iargs [1];
- char *str = mono_method_get_wrapper_data (method, n);
+ char *str = (char *)mono_method_get_wrapper_data (method, n);
if (cfg->compile_aot)
EMIT_NEW_LDSTRLITCONST (cfg, iargs [0], str);
CHECK_OPSIZE (5);
token = read32 (ip + 1);
if (method->wrapper_type != MONO_WRAPPER_NONE) {
- field = mono_method_get_wrapper_data (method, token);
+ field = (MonoClassField *)mono_method_get_wrapper_data (method, token);
klass = field->parent;
}
else {
if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD ||
method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED) {
handle = mono_method_get_wrapper_data (method, n);
- handle_class = mono_method_get_wrapper_data (method, n + 1);
+ handle_class = (MonoClass *)mono_method_get_wrapper_data (method, n + 1);
if (handle_class == mono_defaults.typehandle_class)
handle = &((MonoClass*)handle)->byval_arg;
}
typeof(Gen<>). */
context_used = 0;
} else if (handle_class == mono_defaults.typehandle_class) {
- context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type (handle));
+ context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type ((MonoType *)handle));
} else if (handle_class == mono_defaults.fieldhandle_class)
context_used = mini_class_check_context_used (cfg, ((MonoClassField*)handle)->parent);
else if (handle_class == mono_defaults.methodhandle_class)
- context_used = mini_method_check_context_used (cfg, handle);
+ context_used = mini_method_check_context_used (cfg, (MonoMethod *)handle);
else
g_assert_not_reached ();
}
(cmethod = mini_get_method (cfg, method, read32 (ip + 6), NULL, generic_context)) &&
(cmethod->klass == mono_defaults.systemtype_class) &&
(strcmp (cmethod->name, "GetTypeFromHandle") == 0)) {
- MonoClass *tclass = mono_class_from_mono_type (handle);
+ MonoClass *tclass = mono_class_from_mono_type ((MonoType *)handle);
mono_class_init (tclass);
if (context_used) {
EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, image, n, generic_context);
}
} else {
- EMIT_NEW_PCONST (cfg, ins, mono_type_get_object (cfg->domain, handle));
+ EMIT_NEW_PCONST (cfg, ins, mono_type_get_object (cfg->domain, (MonoType *)handle));
}
ins->type = STACK_OBJ;
ins->klass = cmethod->klass;
if (context_used) {
if (handle_class == mono_defaults.typehandle_class) {
ins = emit_get_rgctx_klass (cfg, context_used,
- mono_class_from_mono_type (handle),
+ mono_class_from_mono_type ((MonoType *)handle),
MONO_RGCTX_INFO_TYPE);
} else if (handle_class == mono_defaults.methodhandle_class) {
ins = emit_get_rgctx_method (cfg, context_used,
- handle, MONO_RGCTX_INFO_METHOD);
+ (MonoMethod *)handle, MONO_RGCTX_INFO_METHOD);
} else if (handle_class == mono_defaults.fieldhandle_class) {
ins = emit_get_rgctx_field (cfg, context_used,
- handle, MONO_RGCTX_INFO_CLASS_FIELD);
+ (MonoClassField *)handle, MONO_RGCTX_INFO_CLASS_FIELD);
} else {
g_assert_not_reached ();
}
MonoExceptionClause *clause;
for (tmp = handlers; tmp; tmp = tmp->next) {
- clause = tmp->data;
+ clause = (MonoExceptionClause *)tmp->data;
tblock = cfg->cil_offset_to_bb [clause->handler_offset];
g_assert (tblock);
link_bblock (cfg, cfg->cbb, tblock);
CHECK_OPSIZE (6);
token = read32 (ip + 2);
- cmethod = mono_method_get_wrapper_data (method, token);
+ cmethod = (MonoMethod *)mono_method_get_wrapper_data (method, token);
if (cfg->compile_aot) {
EMIT_NEW_AOTCONST (cfg, ins, MONO_PATCH_INFO_ICALL_ADDR, cmethod);
CHECK_OPSIZE (6);
--sp;
token = read32 (ip + 2);
- klass = mono_method_get_wrapper_data (method, token);
+ klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
g_assert (klass->valuetype);
mono_class_init (klass);
ip += 2;
break;
case CEE_MONO_TLS: {
- int key;
+ MonoTlsKey key;
CHECK_STACK_OVF (1);
CHECK_OPSIZE (6);
- key = (gint32)read32 (ip + 2);
+ key = (MonoTlsKey)read32 (ip + 2);
g_assert (key < TLS_KEY_NUM);
ins = mono_create_tls_get (cfg, key);
cmp->opcode = OP_ICOMPARE;
MONO_ADD_INS (cfg->cbb, cmp);
ins->type = STACK_I4;
- ins->dreg = alloc_dreg (cfg, ins->type);
+ ins->dreg = alloc_dreg (cfg, (MonoStackType)ins->type);
type_from_op (cfg, ins, arg1, arg2);
if (cmp->opcode == OP_FCOMPARE || cmp->opcode == OP_RCOMPARE) {
MonoBasicBlock *bb;
int i, pos;
- vreg_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
+ vreg_to_bb = (gint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
#ifdef MONO_ARCH_SIMD_INTRINSICS
if (cfg->uses_simd_intrinsics)
guint32 *lvregs;
guint32 i, lvregs_len;
gboolean dest_has_lvreg = FALSE;
- guint32 stacktypes [128];
+ MonoStackType stacktypes [128];
MonoInst **live_range_start, **live_range_end;
MonoBasicBlock **live_range_start_bb, **live_range_end_bb;
int *gsharedvt_vreg_to_idx = NULL;
}
if (cfg->gsharedvt) {
- gsharedvt_vreg_to_idx = mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
+ gsharedvt_vreg_to_idx = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
for (i = 0; i < cfg->num_varinfo; ++i) {
MonoInst *ins = cfg->varinfo [i];
* the variable again.
*/
orig_next_vreg = cfg->next_vreg;
- vreg_to_lvreg = mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
- lvregs = mono_mempool_alloc (cfg->mempool, sizeof (guint32) * 1024);
+ vreg_to_lvreg = (guint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
+ lvregs = (guint32 *)mono_mempool_alloc (cfg->mempool, sizeof (guint32) * 1024);
lvregs_len = 0;
/*
* when variable addresses are known.
*/
if (ins->opcode == OP_LDADDR) {
- MonoInst *var = ins->inst_p0;
+ MonoInst *var = (MonoInst *)ins->inst_p0;
if (var->opcode == OP_VTARG_ADDR) {
/* Happens on SPARC/S390 where vtypes are passed by reference */
gboolean is_pinvoke = sig->pinvoke;
if (mp)
- cinfo = mono_mempool_alloc0 (mp, sizeof (CallInfo) + (sizeof (ArgInfo) * n));
+ cinfo = (CallInfo *)mono_mempool_alloc0 (mp, sizeof (CallInfo) + (sizeof (ArgInfo) * n));
else
- cinfo = g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
+ cinfo = (CallInfo *)g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
cinfo->nargs = n;
if (!cfg->arch.cinfo)
cfg->arch.cinfo = get_call_info (cfg->mempool, sig);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
/*
* FIXME: Remove some of the restrictions.
sig = mono_method_signature (cfg->method);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
sig_ret = mini_get_underlying_type (sig->ret);
/*
sig = mono_method_signature (cfg->method);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
sig_ret = mini_get_underlying_type (sig->ret);
mono_arch_compute_omit_fp (cfg);
if (!cfg->arch.cinfo)
cfg->arch.cinfo = get_call_info (cfg->mempool, sig);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
if (cinfo->ret.storage == ArgValuetypeInReg)
cfg->ret_var_is_local = TRUE;
} while (0);
static guint8*
-emit_call_body (MonoCompile *cfg, guint8 *code, guint32 patch_type, gconstpointer data)
+emit_call_body (MonoCompile *cfg, guint8 *code, MonoJumpInfoType patch_type, gconstpointer data)
{
gboolean no_patch = FALSE;
* The call might go directly to a native function without
* the wrapper.
*/
- MonoJitICallInfo *mi = mono_find_jit_icall_by_name (data);
+ MonoJitICallInfo *mi = mono_find_jit_icall_by_name ((const char *)data);
if (mi) {
gconstpointer target = mono_icall_get_wrapper (mi);
if ((((guint64)target) >> 32) != 0)
MonoJumpInfo *jinfo = NULL;
if (cfg->abs_patches)
- jinfo = g_hash_table_lookup (cfg->abs_patches, data);
+ jinfo = (MonoJumpInfo *)g_hash_table_lookup (cfg->abs_patches, data);
if (jinfo) {
if (jinfo->type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
MonoJitICallInfo *mi = mono_find_jit_icall_by_name (jinfo->data.name);
}
static inline guint8*
-emit_call (MonoCompile *cfg, guint8 *code, guint32 patch_type, gconstpointer data, gboolean win64_adjust_stack)
+emit_call (MonoCompile *cfg, guint8 *code, MonoJumpInfoType patch_type, gconstpointer data, gboolean win64_adjust_stack)
{
#ifdef TARGET_WIN32
if (win64_adjust_stack)
case OP_VCALL2_MEMBASE:
cinfo = get_call_info (cfg->mempool, ((MonoCallInst*)ins)->signature);
if (cinfo->ret.storage == ArgValuetypeInReg) {
- MonoInst *loc = cfg->arch.vret_addr_loc;
+ MonoInst *loc = (MonoInst *)cfg->arch.vret_addr_loc;
/* Load the destination address */
g_assert (loc->opcode == OP_REGOFFSET);
if (G_UNLIKELY (offset > (cfg->code_size - max_len - EXTRA_CODE_SPACE))) {
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code(cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code(cfg);
code = cfg->native_code + offset;
cfg->stat_code_reallocs++;
}
break;
case OP_SEQ_POINT: {
if (ins->flags & MONO_INST_SINGLE_STEP_LOC) {
- MonoInst *var = cfg->arch.ss_tramp_var;
+ MonoInst *var = (MonoInst *)cfg->arch.ss_tramp_var;
guint8 *label;
/* Load ss_tramp_var */
if (cfg->compile_aot) {
guint32 offset = code - cfg->native_code;
guint32 val;
- MonoInst *info_var = cfg->arch.seq_point_info_var;
+ MonoInst *info_var = (MonoInst *)cfg->arch.seq_point_info_var;
guint8 *label;
/* Load info var */
amd64_call_reg (code, AMD64_R11);
amd64_patch (label, code);
} else {
- MonoInst *var = cfg->arch.bp_tramp_var;
+ MonoInst *var = (MonoInst *)cfg->arch.bp_tramp_var;
guint8 *label;
/*
case OP_COND_EXC_IGE_UN:
case OP_COND_EXC_ILE:
case OP_COND_EXC_ILE_UN:
- EMIT_COND_SYSTEM_EXCEPTION (cc_table [mono_opcode_to_cond (ins->opcode)], cc_signed_table [mono_opcode_to_cond (ins->opcode)], ins->inst_p1);
+ EMIT_COND_SYSTEM_EXCEPTION (cc_table [mono_opcode_to_cond (ins->opcode)], cc_signed_table [mono_opcode_to_cond (ins->opcode)], (const char *)ins->inst_p1);
break;
case OP_COND_EXC_OV:
case OP_COND_EXC_NO:
case OP_COND_EXC_C:
case OP_COND_EXC_NC:
EMIT_COND_SYSTEM_EXCEPTION (branch_cc_table [ins->opcode - OP_COND_EXC_EQ],
- (ins->opcode < OP_COND_EXC_NE_UN), ins->inst_p1);
+ (ins->opcode < OP_COND_EXC_NE_UN), (const char *)ins->inst_p1);
break;
case OP_COND_EXC_IOV:
case OP_COND_EXC_INO:
case OP_COND_EXC_IC:
case OP_COND_EXC_INC:
EMIT_COND_SYSTEM_EXCEPTION (branch_cc_table [ins->opcode - OP_COND_EXC_IEQ],
- (ins->opcode < OP_COND_EXC_INE_UN), ins->inst_p1);
+ (ins->opcode < OP_COND_EXC_INE_UN), (const char *)ins->inst_p1);
break;
/* floating point opcodes */
cfg->code_size = MAX (cfg->header->code_size * 4, 1024);
#if defined(__default_codegen__)
- code = cfg->native_code = g_malloc (cfg->code_size);
+ code = cfg->native_code = (unsigned char *)g_malloc (cfg->code_size);
#elif defined(__native_client_codegen__)
/* native_code_alloc is not 32-byte aligned, native_code is. */
cfg->native_code_alloc = g_malloc (cfg->code_size + kNaClAlignment);
if (G_UNLIKELY (required_code_size >= (cfg->code_size - offset))) {
while (required_code_size >= (cfg->code_size - offset))
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code (cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code (cfg);
code = cfg->native_code + offset;
cfg->stat_code_reallocs++;
}
sig = mono_method_signature (method);
pos = 0;
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
if (sig->ret->type != MONO_TYPE_VOID) {
/* Save volatile arguments to the stack */
if (trace) {
args_clobbered = TRUE;
- code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
+ code = (guint8 *)mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
}
if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
}
if (cfg->gen_sdb_seq_points) {
- MonoInst *info_var = cfg->arch.seq_point_info_var;
+ MonoInst *info_var = (MonoInst *)cfg->arch.seq_point_info_var;
/* Initialize seq_point_info_var */
if (cfg->compile_aot) {
if (cfg->compile_aot) {
/* Initialize ss_tramp_var */
- ins = cfg->arch.ss_tramp_var;
+ ins = (MonoInst *)cfg->arch.ss_tramp_var;
g_assert (ins->opcode == OP_REGOFFSET);
amd64_mov_reg_membase (code, AMD64_R11, info_var->inst_basereg, info_var->inst_offset, 8);
amd64_mov_membase_reg (code, ins->inst_basereg, ins->inst_offset, AMD64_R11, 8);
} else {
/* Initialize ss_tramp_var */
- ins = cfg->arch.ss_tramp_var;
+ ins = (MonoInst *)cfg->arch.ss_tramp_var;
g_assert (ins->opcode == OP_REGOFFSET);
amd64_mov_reg_imm (code, AMD64_R11, (guint64)&ss_trampoline);
amd64_mov_membase_reg (code, ins->inst_basereg, ins->inst_offset, AMD64_R11, 8);
/* Initialize bp_tramp_var */
- ins = cfg->arch.bp_tramp_var;
+ ins = (MonoInst *)cfg->arch.bp_tramp_var;
g_assert (ins->opcode == OP_REGOFFSET);
amd64_mov_reg_imm (code, AMD64_R11, (guint64)&bp_trampoline);
while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code (cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code (cfg);
cfg->stat_code_reallocs++;
}
code = cfg->native_code + cfg->code_len;
mono_emit_unwind_op_remember_state (cfg, code);
if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
- code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
+ code = (guint8 *)mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
/* the code restoring the registers must be kept in sync with OP_TAILCALL */
}
/* Load returned vtypes into registers if needed */
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
if (cinfo->ret.storage == ArgValuetypeInReg) {
ArgInfo *ainfo = &cinfo->ret;
MonoInst *inst = cfg->ret;
while (cfg->code_len + code_size > (cfg->code_size - 16)) {
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code (cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code (cfg);
cfg->stat_code_reallocs++;
}
void*
mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
{
- guchar *code = p;
+ guchar *code = (guchar *)p;
MonoMethodSignature *sig;
MonoInst *inst;
int i, n, stack_area = 0;
void*
mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers)
{
- guchar *code = p;
+ guchar *code = (guchar *)p;
int save_mode = SAVE_NONE;
MonoMethod *method = cfg->method;
MonoType *ret_type = mini_get_underlying_type (mono_method_signature (method)->ret);
unwind_ops = mono_arch_get_cie_program ();
if (has_target) {
- start = code = mono_global_codeman_reserve (64);
+ start = code = (guint8 *)mono_global_codeman_reserve (64);
/* Replace the this argument with the target */
amd64_mov_reg_reg (code, AMD64_RAX, AMD64_ARG_REG1, 8);
g_assert ((code - start) < 64);
} else {
- start = code = mono_global_codeman_reserve (64);
+ start = code = (guint8 *)mono_global_codeman_reserve (64);
if (param_count == 0) {
amd64_jump_membase (code, AMD64_ARG_REG1, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr));
if (offset / (int)sizeof (gpointer) > MAX_VIRTUAL_DELEGATE_OFFSET)
return NULL;
- start = code = mono_global_codeman_reserve (size);
+ start = code = (guint8 *)mono_global_codeman_reserve (size);
unwind_ops = mono_arch_get_cie_program ();
return cached;
if (mono_aot_only) {
- start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
+ start = (guint8 *)mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
} else {
MonoTrampInfo *info;
- start = get_delegate_invoke_impl (&info, TRUE, 0);
+ start = (guint8 *)get_delegate_invoke_impl (&info, TRUE, 0);
mono_tramp_info_register (info, NULL);
}
if (mono_aot_only) {
char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", sig->param_count);
- start = mono_aot_get_trampoline (name);
+ start = (guint8 *)mono_aot_get_trampoline (name);
g_free (name);
} else {
MonoTrampInfo *info;
- start = get_delegate_invoke_impl (&info, FALSE, sig->param_count);
+ start = (guint8 *)get_delegate_invoke_impl (&info, FALSE, sig->param_count);
mono_tramp_info_register (info, NULL);
}
code = mono_domain_code_reserve (domain, size);
#else
if (fail_tramp)
- code = mono_method_alloc_generic_virtual_thunk (domain, size);
+ code = (guint8 *)mono_method_alloc_generic_virtual_thunk (domain, size);
else
- code = mono_domain_code_reserve (domain, size);
+ code = (guint8 *)mono_domain_code_reserve (domain, size);
#endif
start = code;
char *bp;
/*Load the spvar*/
- bp = MONO_CONTEXT_GET_BP (ctx);
- sp = *(gpointer*)(bp + clause->exvar_offset);
+ bp = (char *)MONO_CONTEXT_GET_BP (ctx);
+ sp = (gpointer *)*(gpointer*)(bp + clause->exvar_offset);
old_value = *sp;
if (old_value < ji->code_start || (char*)old_value > ((char*)ji->code_start + ji->code_size))
* On AMD64, the result is placed into R11.
*/
guint8*
-mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target)
+mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, MonoJumpInfoType tramp_type, gconstpointer target)
{
*ji = mono_patch_info_list_prepend (*ji, code - start, tramp_type, target);
amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
if (ji->from_aot) {
guint32 native_offset = ip - (guint8*)ji->code_start;
- SeqPointInfo *info = mono_arch_get_seq_point_info (mono_domain_get (), ji->code_start);
+ SeqPointInfo *info = (SeqPointInfo *)mono_arch_get_seq_point_info (mono_domain_get (), (guint8 *)ji->code_start);
g_assert (info->bp_addrs [native_offset] == 0);
info->bp_addrs [native_offset] = mini_get_breakpoint_trampoline ();
if (ji->from_aot) {
guint32 native_offset = ip - (guint8*)ji->code_start;
- SeqPointInfo *info = mono_arch_get_seq_point_info (mono_domain_get (), ji->code_start);
+ SeqPointInfo *info = (SeqPointInfo *)mono_arch_get_seq_point_info (mono_domain_get (), (guint8 *)ji->code_start);
info->bp_addrs [native_offset] = NULL;
} else {
// FIXME: Add a free function
mono_domain_lock (domain);
- info = g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
+ info = (SeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
code);
mono_domain_unlock (domain);
g_assert (ji);
// FIXME: Optimize the size
- info = g_malloc0 (sizeof (SeqPointInfo) + (ji->code_size * sizeof (gpointer)));
+ info = (SeqPointInfo *)g_malloc0 (sizeof (SeqPointInfo) + (ji->code_size * sizeof (gpointer)));
info->ss_tramp_addr = &ss_trampoline;
if (rs->next_vreg > rs->vassign_size) {
g_free (rs->vassign);
rs->vassign_size = MAX (rs->next_vreg, 256);
- rs->vassign = g_malloc (rs->vassign_size * sizeof (gint32));
+ rs->vassign = (gint32 *)g_malloc (rs->vassign_size * sizeof (gint32));
}
memset (rs->isymbolic, 0, MONO_MAX_IREGS * sizeof (rs->isymbolic [0]));
g_assert (bank < MONO_NUM_REGBANKS);
- new_info = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoSpillInfo) * new_len);
+ new_info = (MonoSpillInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoSpillInfo) * new_len);
if (orig_info)
memcpy (new_info, orig_info, sizeof (MonoSpillInfo) * orig_len);
for (i = orig_len; i < new_len; ++i)
if (cfg->reginfo && cfg->reginfo_len < max)
cfg->reginfo = NULL;
- reginfo = cfg->reginfo;
+ reginfo = (RegTrack *)cfg->reginfo;
if (!reginfo) {
cfg->reginfo_len = MAX (1024, max * 2);
- reginfo = cfg->reginfo = mono_mempool_alloc (cfg->mempool, sizeof (RegTrack) * cfg->reginfo_len);
+ reginfo = (RegTrack *)mono_mempool_alloc (cfg->mempool, sizeof (RegTrack) * cfg->reginfo_len);
+ cfg->reginfo = reginfo;
}
else
g_assert (cfg->reginfo_len >= rs->next_vreg);
default:
printf ("%s\n", mono_inst_name (opcode));
g_assert_not_reached ();
- return 0;
+ return (CompRelation)0;
}
}
}
} else {
g_error ("Unknown opcode '%s' in opcode_to_type", mono_inst_name (opcode));
- return 0;
+ return (CompType)0;
}
}
if (mono_llvm_only)
cbs.mono_raise_exception = mono_llvm_raise_exception;
else
- cbs.mono_raise_exception = mono_get_throw_exception ();
+ cbs.mono_raise_exception = (void (*)(MonoException *))mono_get_throw_exception ();
cbs.mono_raise_exception_with_ctx = mono_raise_exception_with_ctx;
cbs.mono_exception_walk_trace = mono_exception_walk_trace;
cbs.mono_install_handler_block_guard = mono_install_handler_block_guard;
if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
ji = prev_ji;
else
- ji = mini_jit_info_table_find (domain, ip, NULL);
+ ji = mini_jit_info_table_find (domain, (char *)ip, NULL);
if (managed)
*managed = FALSE;
err = mono_arch_unwind_frame (domain, jit_tls, ji, ctx, new_ctx, lmf, NULL, &frame);
if (!err)
- return (gpointer)-1;
+ return (MonoJitInfo *)-1;
if (*lmf && ((*lmf) != jit_tls->first_lmf) && ((gpointer)MONO_CONTEXT_GET_SP (new_ctx) >= (gpointer)(*lmf))) {
/*
* Remove any unused lmf.
* Mask out the lower bits which might be used to hold additional information.
*/
- *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~(SIZEOF_VOID_P -1));
+ *lmf = (MonoLMF *)(((gsize)(*lmf)->previous_lmf) & ~(SIZEOF_VOID_P -1));
}
/* Convert between the new and the old APIs */
if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
ji = prev_ji;
else
- ji = mini_jit_info_table_find (domain, ip, &target_domain);
+ ji = mini_jit_info_table_find (domain, (char *)ip, &target_domain);
if (!target_domain)
target_domain = domain;
* Remove any unused lmf.
* Mask out the lower bits which might be used to hold additional information.
*/
- *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~(SIZEOF_VOID_P -1));
+ *lmf = (MonoLMF *)(((gsize)(*lmf)->previous_lmf) & ~(SIZEOF_VOID_P -1));
}
if (frame->ji && !frame->ji->is_trampoline && !frame->ji->async)
return info;
} else {
/* Avoid returning a managed object */
- MonoObject *this_obj = info;
+ MonoObject *this_obj = (MonoObject *)info;
return this_obj->vtable->klass;
}
method = jinfo_get_method (ji);
g_assert (method->is_inflated);
if (mono_method_get_context (method)->method_inst) {
- MonoMethodRuntimeGenericContext *mrgctx = generic_info;
+ MonoMethodRuntimeGenericContext *mrgctx = (MonoMethodRuntimeGenericContext *)generic_info;
klass = mrgctx->class_vtable->klass;
context.method_inst = mrgctx->method_inst;
g_assert (context.method_inst);
} else if ((method->flags & METHOD_ATTRIBUTE_STATIC) || method->klass->valuetype) {
- MonoVTable *vtable = generic_info;
+ MonoVTable *vtable = (MonoVTable *)generic_info;
klass = vtable->klass;
} else {
- klass = generic_info;
+ klass = (MonoClass *)generic_info;
}
//g_assert (!method->klass->generic_container);
for (i = 0; i < len; i++) {
gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
- MonoJitInfo *ji = mono_jit_info_table_find (domain, ip);
+ MonoJitInfo *ji = mono_jit_info_table_find (domain, (char *)ip);
if (ji == NULL) {
if (func (NULL, ip, 0, FALSE, user_data))
gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
MonoMethod *method;
- ji = mono_jit_info_table_find (domain, ip);
+ ji = mono_jit_info_table_find (domain, (char *)ip);
if (ji == NULL) {
/* Unmanaged frame */
mono_array_setref (res, i, sf);
mono_runtime_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data)
{
if (!start_ctx) {
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
if (jit_tls && jit_tls->orig_ex_ctx_set)
start_ctx = &jit_tls->orig_ex_ctx;
}
start_ctx = &extra_ctx;
}
- mono_walk_stack_full (func, start_ctx, mono_domain_get (), thread->jit_data, mono_get_lmf (), unwind_options, user_data);
+ mono_walk_stack_full (func, start_ctx, mono_domain_get (), (MonoJitTlsData *)thread->jit_data, mono_get_lmf (), unwind_options, user_data);
}
/**
mono_walk_stack_full (func,
&state->ctx,
- state->unwind_data [MONO_UNWIND_DATA_DOMAIN],
- state->unwind_data [MONO_UNWIND_DATA_JIT_TLS],
- state->unwind_data [MONO_UNWIND_DATA_LMF],
+ (MonoDomain *)state->unwind_data [MONO_UNWIND_DATA_DOMAIN],
+ (MonoJitTlsData *)state->unwind_data [MONO_UNWIND_DATA_JIT_TLS],
+ (MonoLMF *)state->unwind_data [MONO_UNWIND_DATA_LMF],
unwind_options, user_data);
}
MonoString **file, gint32 *line, gint32 *column)
{
MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoJitInfo *ji = NULL;
MonoContext ctx, new_ctx;
if (!t)
return NULL;
- refs = (t->appdomain_refs) ? *(gpointer *) t->appdomain_refs : NULL;
+ refs = (gpointer *)((t->appdomain_refs) ? *(gpointer *) t->appdomain_refs : NULL);
for (; refs && *refs; refs++) {
if (*refs != domain && *refs != mono_get_root_domain ()) {
ji = mono_jit_info_table_find_internal ((MonoDomain*) *refs, addr, TRUE, allow_trampolines);
if (named_type != 0x54)
continue;
name_len = mono_metadata_decode_blob_size (p, &p);
- name = g_malloc (name_len + 1);
+ name = (char *)g_malloc (name_len + 1);
memcpy (name, p, name_len);
name [name_len] = 0;
p += name_len;
* OUT_FILTER_IDX. Return TRUE if the exception is caught, FALSE otherwise.
*/
static gboolean
-mono_handle_exception_internal_first_pass (MonoContext *ctx, gpointer obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoJitInfo **out_prev_ji, MonoObject *non_exception)
+mono_handle_exception_internal_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoJitInfo **out_prev_ji, MonoObject *non_exception)
{
MonoDomain *domain = mono_domain_get ();
MonoJitInfo *ji = NULL;
static int (*call_filter) (MonoContext *, gpointer) = NULL;
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoArray *initial_trace_ips = NULL;
GList *trace_ips = NULL;
g_assert (ctx != NULL);
- if (obj == domain->stack_overflow_ex)
+ if (obj == (MonoObject *)domain->stack_overflow_ex)
stack_overflow = TRUE;
mono_ex = (MonoException*)obj;
}
if (!call_filter)
- call_filter = mono_get_call_filter ();
+ call_filter = (int (*) (MonoContext *, void *))mono_get_call_filter ();
g_assert (jit_tls->end_of_stack);
g_assert (jit_tls->abort_func);
* @resume: whenever to resume unwinding based on the state in MonoJitTlsData.
*/
static gboolean
-mono_handle_exception_internal (MonoContext *ctx, gpointer obj, gboolean resume, MonoJitInfo **out_ji)
+mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resume, MonoJitInfo **out_ji)
{
MonoDomain *domain = mono_domain_get ();
MonoJitInfo *ji, *prev_ji;
static int (*call_filter) (MonoContext *, gpointer) = NULL;
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoException *mono_ex;
gboolean stack_overflow = FALSE;
/*
* Allocate a new exception object instead of the preconstructed ones.
*/
- if (obj == domain->stack_overflow_ex) {
+ if (obj == (MonoObject *)domain->stack_overflow_ex) {
/*
* It is not a good idea to try and put even more pressure on the little stack available.
* obj = mono_get_exception_stack_overflow ();
*/
stack_overflow = TRUE;
}
- else if (obj == domain->null_reference_ex) {
- obj = mono_get_exception_null_reference ();
+ else if (obj == (MonoObject *)domain->null_reference_ex) {
+ obj = (MonoObject *)mono_get_exception_null_reference ();
}
if (!mono_object_isinst (obj, mono_defaults.exception_class)) {
non_exception = obj;
- obj = mono_get_exception_runtime_wrapped (obj);
+ obj = (MonoObject *)mono_get_exception_runtime_wrapped (obj);
}
mono_ex = (MonoException*)obj;
}
if (!call_filter)
- call_filter = mono_get_call_filter ();
+ call_filter = (int (*)(MonoContext *, void*))mono_get_call_filter ();
g_assert (jit_tls->end_of_stack);
g_assert (jit_tls->abort_func);
if (!res) {
if (mini_get_debug_options ()->break_on_exc)
G_BREAKPOINT ();
- mono_debugger_agent_handle_exception (obj, ctx, NULL);
+ mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, NULL);
if (mini_get_debug_options ()->suspend_on_unhandled) {
mono_runtime_printf_err ("Unhandled exception, suspending...");
}
if (unhandled)
- mono_debugger_agent_handle_exception (obj, ctx, NULL);
+ mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, NULL);
else
- mono_debugger_agent_handle_exception (obj, ctx, &ctx_cp);
+ mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, &ctx_cp);
}
}
* There aren't any further finally/fault handler blocks down the stack over this exception.
* This must be ensured by the code that installs the guard trampoline.
*/
- g_assert (ji == mini_jit_info_table_find (domain, MONO_CONTEXT_GET_IP (&jit_tls->handler_block_context), NULL));
+ g_assert (ji == mini_jit_info_table_find (domain, (char *)MONO_CONTEXT_GET_IP (&jit_tls->handler_block_context), NULL));
if (!is_address_protected (ji, jit_tls->handler_block, ei->handler_start)) {
is_outside = TRUE;
#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_depth += frame_count;
#endif
- if (obj == domain->stack_overflow_ex)
+ if (obj == (MonoObject *)domain->stack_overflow_ex)
jit_tls->handling_stack_ovf = FALSE;
return 0;
{
static int (*call_filter) (MonoContext *, gpointer) = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoContext ctx, new_ctx;
MonoJitInfo *ji, rji;
return;
if (!call_filter)
- call_filter = mono_get_call_filter ();
+ call_filter = (int (*)(MonoContext *, void *))mono_get_call_filter ();
for (i = 0; i < ji->num_clauses; i++) {
MonoJitExceptionInfo *ei = &ji->clauses [i];
* @obj: the exception object
*/
gboolean
-mono_handle_exception (MonoContext *ctx, gpointer obj)
+mono_handle_exception (MonoContext *ctx, MonoObject *obj)
{
#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_thrown++;
static G_GNUC_UNUSED void
try_more_restore (void)
{
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
if (try_restore_stack_protection (jit_tls, 500))
jit_tls->restore_stack_prot = NULL;
}
static G_GNUC_UNUSED void
restore_stack_protection (void)
{
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoException *ex = mono_domain_get ()->stack_overflow_ex;
/* if we can't restore the stack protection, keep a callback installed so
* we'll try to restore as much stack as we can at each return from unmanaged
gpointer
mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
{
- void (*func)(void) = (gpointer)tramp_data;
+ void (*func)(void) = (void (*)(void))tramp_data;
func ();
return NULL;
}
print_overflow_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
MonoMethod *method = NULL;
- PrintOverflowUserData *user_data = data;
+ PrintOverflowUserData *user_data = (PrintOverflowUserData *)data;
gchar *location;
if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
#ifdef MONO_ARCH_USE_SIGACTION
struct sigaction sa;
#endif
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
if (handling_sigsegv)
if (jit_tls && mono_thread_internal_current ()) {
mono_runtime_printf_err ("Stacktrace:\n");
- mono_walk_stack (print_stack_frame_to_stderr, TRUE, NULL);
+ /* FIXME: Is MONO_UNWIND_LOOKUP_IL_OFFSET correct here? */
+ mono_walk_stack (print_stack_frame_to_stderr, MONO_UNWIND_LOOKUP_IL_OFFSET, NULL);
}
#ifdef HAVE_BACKTRACE_SYMBOLS
void
mono_resume_unwind (MonoContext *ctx)
{
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
MonoContext new_ctx;
MONO_CONTEXT_SET_IP (ctx, MONO_CONTEXT_GET_IP (&jit_tls->resume_state.ctx));
MONO_CONTEXT_SET_SP (ctx, MONO_CONTEXT_GET_SP (&jit_tls->resume_state.ctx));
new_ctx = *ctx;
- mono_handle_exception_internal (&new_ctx, jit_tls->resume_state.ex_obj, TRUE, NULL);
+ mono_handle_exception_internal (&new_ctx, (MonoObject *)jit_tls->resume_state.ex_obj, TRUE, NULL);
mono_restore_context (&new_ctx);
}
{
int i;
gpointer ip;
- FindHandlerBlockData *pdata = data;
+ FindHandlerBlockData *pdata = (FindHandlerBlockData *)data;
MonoJitInfo *ji = frame->ji;
if (!ji)
mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
{
FindHandlerBlockData data = { 0 };
- MonoJitTlsData *jit_tls = ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS];
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS];
gpointer resume_ip;
/* FIXME */
MonoJitTlsData *jit_tls = NULL;
if (mini_get_debug_options ()->better_cast_details) {
- jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
jit_tls->class_cast_from = from;
jit_tls->class_cast_to = to;
}
static void
mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx)
{
- mono_handle_exception (ctx, exc);
+ mono_handle_exception (ctx, (MonoObject *)exc);
mono_restore_context (ctx);
}
mono_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
{
#ifdef MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
jit_tls->ex_ctx = *ctx;
mono_arch_setup_async_callback (ctx, async_cb, user_data);
static void (*restore_context) (MonoContext *);
if (!restore_context)
- restore_context = mono_get_restore_context ();
+ restore_context = (void (*)(MonoContext *))mono_get_restore_context ();
restore_context (ctx);
g_assert_not_reached ();
}
* LOCKING: loader lock
*/
static MonoRuntimeGenericContextInfoTemplate*
-get_info_templates (MonoRuntimeGenericContextTemplate *template, int type_argc)
+get_info_templates (MonoRuntimeGenericContextTemplate *template_, int type_argc)
{
g_assert (type_argc >= 0);
if (type_argc == 0)
- return template->infos;
- return g_slist_nth_data (template->method_templates, type_argc - 1);
+ return template_->infos;
+ return (MonoRuntimeGenericContextInfoTemplate *)g_slist_nth_data (template_->method_templates, type_argc - 1);
}
/*
* LOCKING: loader lock
*/
static void
-set_info_templates (MonoImage *image, MonoRuntimeGenericContextTemplate *template, int type_argc,
+set_info_templates (MonoImage *image, MonoRuntimeGenericContextTemplate *template_, int type_argc,
MonoRuntimeGenericContextInfoTemplate *oti)
{
g_assert (type_argc >= 0);
if (type_argc == 0)
- template->infos = oti;
+ template_->infos = oti;
else {
- int length = g_slist_length (template->method_templates);
+ int length = g_slist_length (template_->method_templates);
GSList *list;
/* FIXME: quadratic! */
while (length < type_argc) {
- template->method_templates = g_slist_append_image (image, template->method_templates, NULL);
+ template_->method_templates = g_slist_append_image (image, template_->method_templates, NULL);
length++;
}
- list = g_slist_nth (template->method_templates, type_argc - 1);
+ list = g_slist_nth (template_->method_templates, type_argc - 1);
g_assert (list);
list->data = oti;
}
* LOCKING: loader lock
*/
static int
-template_get_max_argc (MonoRuntimeGenericContextTemplate *template)
+template_get_max_argc (MonoRuntimeGenericContextTemplate *template_)
{
- return g_slist_length (template->method_templates);
+ return g_slist_length (template_->method_templates);
}
/*
* LOCKING: loader lock
*/
static MonoRuntimeGenericContextInfoTemplate*
-rgctx_template_get_other_slot (MonoRuntimeGenericContextTemplate *template, int type_argc, int slot)
+rgctx_template_get_other_slot (MonoRuntimeGenericContextTemplate *template_, int type_argc, int slot)
{
int i;
MonoRuntimeGenericContextInfoTemplate *oti;
g_assert (slot >= 0);
- for (oti = get_info_templates (template, type_argc), i = 0; i < slot; oti = oti->next, ++i) {
+ for (oti = get_info_templates (template_, type_argc), i = 0; i < slot; oti = oti->next, ++i) {
if (!oti)
return NULL;
}
* LOCKING: loader lock
*/
static int
-rgctx_template_num_infos (MonoRuntimeGenericContextTemplate *template, int type_argc)
+rgctx_template_num_infos (MonoRuntimeGenericContextTemplate *template_, int type_argc)
{
MonoRuntimeGenericContextInfoTemplate *oti;
int i;
- for (i = 0, oti = get_info_templates (template, type_argc); oti; ++i, oti = oti->next)
+ for (i = 0, oti = get_info_templates (template_, type_argc); oti; ++i, oti = oti->next)
;
return i;
static MonoRuntimeGenericContextTemplate*
class_lookup_rgctx_template (MonoClass *klass)
{
- MonoRuntimeGenericContextTemplate *template;
+ MonoRuntimeGenericContextTemplate *template_;
if (!klass->image->rgctx_template_hash)
return NULL;
- template = g_hash_table_lookup (klass->image->rgctx_template_hash, klass);
+ template_ = (MonoRuntimeGenericContextTemplate *)g_hash_table_lookup (klass->image->rgctx_template_hash, klass);
- return template;
+ return template_;
}
/*
if (!generic_subclass_hash)
generic_subclass_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- subclass = g_hash_table_lookup (generic_subclass_hash, parent);
+ subclass = (MonoClass *)g_hash_table_lookup (generic_subclass_hash, parent);
rgctx_template->next_subclass = subclass;
g_hash_table_insert (generic_subclass_hash, parent, klass);
}
num_templates_allocted++;
num_templates_bytes += size;
- return mono_image_alloc0 (klass->image, size);
+ return (MonoRuntimeGenericContextTemplate *)mono_image_alloc0 (klass->image, size);
}
/* LOCKING: Takes the loader lock */
num_oti_allocted++;
num_oti_bytes += size;
- return mono_image_alloc0 (image, size);
+ return (MonoRuntimeGenericContextInfoTemplate *)mono_image_alloc0 (image, size);
}
#define MONO_RGCTX_SLOT_USED_MARKER ((gpointer)&mono_defaults.object_class->byval_arg)
* LOCKING: loader lock
*/
static void
-rgctx_template_set_slot (MonoImage *image, MonoRuntimeGenericContextTemplate *template, int type_argc,
+rgctx_template_set_slot (MonoImage *image, MonoRuntimeGenericContextTemplate *template_, int type_argc,
int slot, gpointer data, MonoRgctxInfoType info_type)
{
static gboolean inited = FALSE;
static int num_data = 0;
int i;
- MonoRuntimeGenericContextInfoTemplate *list = get_info_templates (template, type_argc);
+ MonoRuntimeGenericContextInfoTemplate *list = get_info_templates (template_, type_argc);
MonoRuntimeGenericContextInfoTemplate **oti = &list;
if (!inited) {
(*oti)->data = data;
(*oti)->info_type = info_type;
- set_info_templates (image, template, type_argc, list);
+ set_info_templates (image, template_, type_argc, list);
if (data == MONO_RGCTX_SLOT_USED_MARKER)
++num_markers;
case MONO_RGCTX_INFO_NULLABLE_CLASS_BOX:
case MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX: {
gpointer result = mono_class_inflate_generic_type_with_mempool (temporary ? NULL : klass->image,
- data, context, &error);
+ (MonoType *)data, context, &error);
g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/
return result;
}
case MONO_RGCTX_INFO_METHOD_CONTEXT:
case MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK:
case MONO_RGCTX_INFO_METHOD_DELEGATE_CODE: {
- MonoMethod *method = data;
+ MonoMethod *method = (MonoMethod *)data;
MonoMethod *inflated_method;
MonoType *inflated_type = mono_class_inflate_generic_type (&method->klass->byval_arg, context);
MonoClass *inflated_class = mono_class_from_mono_type (inflated_type);
return inflated_method;
}
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO: {
- MonoGSharedVtMethodInfo *oinfo = data;
+ MonoGSharedVtMethodInfo *oinfo = (MonoGSharedVtMethodInfo *)data;
MonoGSharedVtMethodInfo *res;
MonoDomain *domain = mono_domain_get ();
int i;
- res = mono_domain_alloc0 (domain, sizeof (MonoGSharedVtMethodInfo));
+ res = (MonoGSharedVtMethodInfo *)mono_domain_alloc0 (domain, sizeof (MonoGSharedVtMethodInfo));
/*
res->nlocals = info->nlocals;
res->locals_types = g_new0 (MonoType*, info->nlocals);
res->locals_types [i] = mono_class_inflate_generic_type (info->locals_types [i], context);
*/
res->num_entries = oinfo->num_entries;
- res->entries = mono_domain_alloc0 (domain, sizeof (MonoRuntimeGenericContextInfoTemplate) * oinfo->num_entries);
+ res->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_domain_alloc0 (domain, sizeof (MonoRuntimeGenericContextInfoTemplate) * oinfo->num_entries);
for (i = 0; i < oinfo->num_entries; ++i) {
MonoRuntimeGenericContextInfoTemplate *otemplate = &oinfo->entries [i];
- MonoRuntimeGenericContextInfoTemplate *template = &res->entries [i];
+ MonoRuntimeGenericContextInfoTemplate *template_ = &res->entries [i];
- memcpy (template, otemplate, sizeof (MonoRuntimeGenericContextInfoTemplate));
- template->data = inflate_info (template, context, klass, FALSE);
+ memcpy (template_, otemplate, sizeof (MonoRuntimeGenericContextInfoTemplate));
+ template_->data = inflate_info (template_, context, klass, FALSE);
}
return res;
}
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE:
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT: {
- MonoJumpInfoGSharedVtCall *info = data;
+ MonoJumpInfoGSharedVtCall *info = (MonoJumpInfoGSharedVtCall *)data;
MonoMethod *method = info->method;
MonoMethod *inflated_method;
MonoType *inflated_type = mono_class_inflate_generic_type (&method->klass->byval_arg, context);
MonoJumpInfoGSharedVtCall *res;
MonoDomain *domain = mono_domain_get ();
- res = mono_domain_alloc0 (domain, sizeof (MonoJumpInfoGSharedVtCall));
+ res = (MonoJumpInfoGSharedVtCall *)mono_domain_alloc0 (domain, sizeof (MonoJumpInfoGSharedVtCall));
/* Keep the original signature */
res->sig = info->sig;
case MONO_RGCTX_INFO_CLASS_FIELD:
case MONO_RGCTX_INFO_FIELD_OFFSET: {
- MonoClassField *field = data;
+ MonoClassField *field = (MonoClassField *)data;
MonoType *inflated_type = mono_class_inflate_generic_type (&field->parent->byval_arg, context);
MonoClass *inflated_class = mono_class_from_mono_type (inflated_type);
int i = field - field->parent->fields;
return &inflated_class->fields [i];
}
case MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI: {
- MonoMethodSignature *sig = data;
+ MonoMethodSignature *sig = (MonoMethodSignature *)data;
MonoMethodSignature *isig;
MonoError error;
}
case MONO_RGCTX_INFO_VIRT_METHOD_CODE:
case MONO_RGCTX_INFO_VIRT_METHOD_BOX_TYPE: {
- MonoJumpInfoVirtMethod *info = data;
+ MonoJumpInfoVirtMethod *info = (MonoJumpInfoVirtMethod *)data;
MonoJumpInfoVirtMethod *res;
MonoType *t;
MonoDomain *domain = mono_domain_get ();
MonoError error;
// FIXME: Temporary
- res = mono_domain_alloc0 (domain, sizeof (MonoJumpInfoVirtMethod));
+ res = (MonoJumpInfoVirtMethod *)mono_domain_alloc0 (domain, sizeof (MonoJumpInfoVirtMethod));
t = mono_class_inflate_generic_type (&info->klass->byval_arg, context);
res->klass = mono_class_from_mono_type (t);
mono_metadata_free_type (t);
case MONO_RGCTX_INFO_TYPE:
case MONO_RGCTX_INFO_REFLECTION_TYPE:
case MONO_RGCTX_INFO_CAST_CACHE:
- mono_metadata_free_type (info);
+ mono_metadata_free_type ((MonoType *)info);
break;
default:
break;
static MonoRuntimeGenericContextTemplate*
mono_class_get_runtime_generic_context_template (MonoClass *klass)
{
- MonoRuntimeGenericContextTemplate *parent_template, *template;
+ MonoRuntimeGenericContextTemplate *parent_template, *template_;
guint32 i;
klass = get_shared_class (klass);
mono_loader_lock ();
- template = class_lookup_rgctx_template (klass);
+ template_ = class_lookup_rgctx_template (klass);
mono_loader_unlock ();
- if (template)
- return template;
+ if (template_)
+ return template_;
//g_assert (get_shared_class (class) == class);
- template = alloc_template (klass);
+ template_ = alloc_template (klass);
mono_loader_lock ();
oti = class_get_rgctx_template_oti (klass->parent, type_argc, i, FALSE, FALSE, NULL);
if (oti.data && oti.data != MONO_RGCTX_SLOT_USED_MARKER) {
- rgctx_template_set_slot (klass->image, template, type_argc, i,
+ rgctx_template_set_slot (klass->image, template_, type_argc, i,
oti.data, oti.info_type);
}
}
if (class_lookup_rgctx_template (klass)) {
/* some other thread already set the template */
- template = class_lookup_rgctx_template (klass);
+ template_ = class_lookup_rgctx_template (klass);
} else {
- class_set_rgctx_template (klass, template);
+ class_set_rgctx_template (klass, template_);
if (klass->parent)
register_generic_subclass (klass);
mono_loader_unlock ();
- return template;
+ return template_;
}
/*
return oti;
} else {
- MonoRuntimeGenericContextTemplate *template;
+ MonoRuntimeGenericContextTemplate *template_;
MonoRuntimeGenericContextInfoTemplate *oti;
- template = mono_class_get_runtime_generic_context_template (klass);
- oti = rgctx_template_get_other_slot (template, type_argc, slot);
+ template_ = mono_class_get_runtime_generic_context_template (klass);
+ oti = rgctx_template_get_other_slot (template_, type_argc, slot);
g_assert (oti);
if (temporary)
}
case MONO_RGCTX_INFO_CAST_CACHE: {
/*First slot is the cache itself, the second the vtable.*/
- gpointer **cache_data = mono_domain_alloc0 (domain, sizeof (gpointer) * 2);
- cache_data [1] = (gpointer)klass;
+ gpointer **cache_data = (gpointer **)mono_domain_alloc0 (domain, sizeof (gpointer) * 2);
+ cache_data [1] = (gpointer *)klass;
return cache_data;
}
case MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE:
if (!domain_info->memcpy_addr [size]) {
gpointer addr = mono_compile_method (memcpy_method [size]);
mono_memory_barrier ();
- domain_info->memcpy_addr [size] = addr;
+ domain_info->memcpy_addr [size] = (gpointer *)addr;
}
return domain_info->memcpy_addr [size];
} else {
if (!domain_info->bzero_addr [size]) {
gpointer addr = mono_compile_method (bzero_method [size]);
mono_memory_barrier ();
- domain_info->bzero_addr [size] = addr;
+ domain_info->bzero_addr [size] = (gpointer *)addr;
}
return domain_info->bzero_addr [size];
}
addr = mono_compile_method (method);
// The caller uses the gsharedvt call signature
- ji = mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (addr), NULL);
+ ji = mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (addr), NULL);
g_assert (ji);
if (mini_jit_info_is_gsharedvt (ji))
return mono_create_static_rgctx_trampoline (method, addr);
static guint
tramp_info_hash (gconstpointer key)
{
- GSharedVtTrampInfo *tramp = (gpointer)key;
+ GSharedVtTrampInfo *tramp = (GSharedVtTrampInfo *)key;
return (gsize)tramp->addr;
}
static gboolean
tramp_info_equal (gconstpointer a, gconstpointer b)
{
- GSharedVtTrampInfo *tramp1 = (gpointer)a;
- GSharedVtTrampInfo *tramp2 = (gpointer)b;
+ GSharedVtTrampInfo *tramp1 = (GSharedVtTrampInfo *)a;
+ GSharedVtTrampInfo *tramp2 = (GSharedVtTrampInfo *)b;
/* The signatures should be internalized */
return tramp1->is_in == tramp2->is_in && tramp1->calli == tramp2->calli && tramp1->vcall_offset == tramp2->vcall_offset &&
num_trampolines ++;
/* Cache it */
- tramp_info = mono_domain_alloc0 (domain, sizeof (GSharedVtTrampInfo));
+ tramp_info = (GSharedVtTrampInfo *)mono_domain_alloc0 (domain, sizeof (GSharedVtTrampInfo));
memcpy (tramp_info, &tinfo, sizeof (GSharedVtTrampInfo));
mono_domain_lock (domain);
case MONO_RGCTX_INFO_BZERO:
case MONO_RGCTX_INFO_NULLABLE_CLASS_BOX:
case MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX: {
- MonoClass *arg_class = mono_class_from_mono_type (data);
+ MonoClass *arg_class = mono_class_from_mono_type ((MonoType *)data);
free_inflated_info (oti->info_type, data);
g_assert (arg_class);
case MONO_RGCTX_INFO_TYPE:
return data;
case MONO_RGCTX_INFO_REFLECTION_TYPE:
- return mono_type_get_object (domain, data);
+ return mono_type_get_object (domain, (MonoType *)data);
case MONO_RGCTX_INFO_METHOD:
return data;
case MONO_RGCTX_INFO_GENERIC_METHOD_CODE: {
gpointer addr;
- addr = mono_compile_method (data);
- return mini_add_method_trampoline (data, addr, mono_method_needs_static_rgctx_invoke (data, FALSE), FALSE);
+ addr = mono_compile_method ((MonoMethod *)data);
+ return mini_add_method_trampoline ((MonoMethod *)data, addr, mono_method_needs_static_rgctx_invoke ((MonoMethod *)data, FALSE), FALSE);
}
case MONO_RGCTX_INFO_VIRT_METHOD_CODE: {
- MonoJumpInfoVirtMethod *info = data;
+ MonoJumpInfoVirtMethod *info = (MonoJumpInfoVirtMethod *)data;
MonoClass *iface_class = info->method->klass;
MonoMethod *method;
MonoError error;
return mini_add_method_trampoline (method, addr, mono_method_needs_static_rgctx_invoke (method, FALSE), FALSE);
}
case MONO_RGCTX_INFO_VIRT_METHOD_BOX_TYPE: {
- MonoJumpInfoVirtMethod *info = data;
+ MonoJumpInfoVirtMethod *info = (MonoJumpInfoVirtMethod *)data;
MonoClass *iface_class = info->method->klass;
MonoMethod *method;
MonoClass *impl_class;
}
#ifndef DISABLE_REMOTING
case MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK:
- return mono_compile_method (mono_marshal_get_remoting_invoke_with_check (data));
+ return mono_compile_method (mono_marshal_get_remoting_invoke_with_check ((MonoMethod *)data));
#endif
case MONO_RGCTX_INFO_METHOD_DELEGATE_CODE:
return mono_domain_alloc0 (domain, sizeof (gpointer));
case MONO_RGCTX_INFO_CLASS_FIELD:
return data;
case MONO_RGCTX_INFO_FIELD_OFFSET: {
- MonoClassField *field = data;
+ MonoClassField *field = (MonoClassField *)data;
/* The value is offset by 1 */
if (field->parent->valuetype && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
return GUINT_TO_POINTER (field->offset + 1);
}
case MONO_RGCTX_INFO_METHOD_RGCTX: {
- MonoMethodInflated *method = data;
+ MonoMethodInflated *method = (MonoMethodInflated *)data;
MonoVTable *vtable;
g_assert (method->method.method.is_inflated);
return mono_method_lookup_rgctx (vtable, method->context.method_inst);
}
case MONO_RGCTX_INFO_METHOD_CONTEXT: {
- MonoMethodInflated *method = data;
+ MonoMethodInflated *method = (MonoMethodInflated *)data;
g_assert (method->method.method.is_inflated);
g_assert (method->context.method_inst);
return method->context.method_inst;
}
case MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI: {
- MonoMethodSignature *gsig = oti->data;
- MonoMethodSignature *sig = data;
+ MonoMethodSignature *gsig = (MonoMethodSignature *)oti->data;
+ MonoMethodSignature *sig = (MonoMethodSignature *)data;
gpointer addr;
/*
}
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE:
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT: {
- MonoJumpInfoGSharedVtCall *call_info = data;
+ MonoJumpInfoGSharedVtCall *call_info = (MonoJumpInfoGSharedVtCall *)data;
MonoMethodSignature *call_sig;
MonoMethod *method;
gpointer addr;
MonoJitInfo *callee_ji;
- gboolean virtual = oti->info_type == MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT;
+ gboolean virtual_ = oti->info_type == MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT;
gint32 vcall_offset;
gboolean callee_gsharedvt;
g_assert (method->is_inflated);
- if (!virtual)
+ if (!virtual_)
addr = mono_compile_method (method);
else
addr = NULL;
- if (virtual) {
+ if (virtual_) {
/* Same as in mono_emit_method_call_full () */
if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
/* See mono_emit_method_call_full () */
}
// FIXME: This loads information in the AOT case
- callee_ji = mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (addr), NULL);
+ callee_ji = mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (addr), NULL);
callee_gsharedvt = ji_is_gsharedvt (callee_ji);
/*
* caller -> out trampoline -> in trampoline -> callee
* This is not very efficient, but it is easy to implement.
*/
- if (virtual || !callee_gsharedvt) {
+ if (virtual_ || !callee_gsharedvt) {
MonoMethodSignature *sig, *gsig;
g_assert (method->is_inflated);
return addr;
}
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO: {
- MonoGSharedVtMethodInfo *info = data;
+ MonoGSharedVtMethodInfo *info = (MonoGSharedVtMethodInfo *)data;
MonoGSharedVtMethodRuntimeInfo *res;
MonoType *t;
int i, offset, align, size;
// FIXME:
- res = g_malloc0 (sizeof (MonoGSharedVtMethodRuntimeInfo) + (info->num_entries * sizeof (gpointer)));
+ res = (MonoGSharedVtMethodRuntimeInfo *)g_malloc0 (sizeof (MonoGSharedVtMethodRuntimeInfo) + (info->num_entries * sizeof (gpointer)));
offset = 0;
for (i = 0; i < info->num_entries; ++i) {
- MonoRuntimeGenericContextInfoTemplate *template = &info->entries [i];
+ MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
- switch (template->info_type) {
+ switch (template_->info_type) {
case MONO_RGCTX_INFO_LOCAL_OFFSET:
- t = template->data;
+ t = (MonoType *)template_->data;
size = mono_type_size (t, &align);
offset += size;
break;
default:
- res->entries [i] = instantiate_info (domain, template, context, klass);
+ res->entries [i] = instantiate_info (domain, template_, context, klass);
break;
}
}
static void
fill_in_rgctx_template_slot (MonoClass *klass, int type_argc, int index, gpointer data, MonoRgctxInfoType info_type)
{
- MonoRuntimeGenericContextTemplate *template = mono_class_get_runtime_generic_context_template (klass);
+ MonoRuntimeGenericContextTemplate *template_ = mono_class_get_runtime_generic_context_template (klass);
MonoClass *subclass;
- rgctx_template_set_slot (klass->image, template, type_argc, index, data, info_type);
+ rgctx_template_set_slot (klass->image, template_, type_argc, index, data, info_type);
/* Recurse for all subclasses */
if (generic_subclass_hash)
- subclass = g_hash_table_lookup (generic_subclass_hash, klass);
+ subclass = (MonoClass *)g_hash_table_lookup (generic_subclass_hash, klass);
else
subclass = NULL;
register_info (MonoClass *klass, int type_argc, gpointer data, MonoRgctxInfoType info_type)
{
int i;
- MonoRuntimeGenericContextTemplate *template = mono_class_get_runtime_generic_context_template (klass);
+ MonoRuntimeGenericContextTemplate *template_ = mono_class_get_runtime_generic_context_template (klass);
MonoClass *parent;
MonoRuntimeGenericContextInfoTemplate *oti;
- for (i = 0, oti = get_info_templates (template, type_argc); oti; ++i, oti = oti->next) {
+ for (i = 0, oti = get_info_templates (template_, type_argc); oti; ++i, oti = oti->next) {
if (!oti->data)
break;
}
break;
rgctx_template_set_slot (parent->image, parent_template, type_argc, i,
- MONO_RGCTX_SLOT_USED_MARKER, 0);
+ MONO_RGCTX_SLOT_USED_MARKER, (MonoRgctxInfoType)0);
parent = parent->parent;
}
case MONO_RGCTX_INFO_BZERO:
case MONO_RGCTX_INFO_NULLABLE_CLASS_BOX:
case MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX:
- return mono_class_from_mono_type (data1) == mono_class_from_mono_type (data2);
+ return mono_class_from_mono_type ((MonoType *)data1) == mono_class_from_mono_type ((MonoType *)data2);
case MONO_RGCTX_INFO_METHOD:
case MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO:
case MONO_RGCTX_INFO_GENERIC_METHOD_CODE:
return data1 == data2;
case MONO_RGCTX_INFO_VIRT_METHOD_CODE:
case MONO_RGCTX_INFO_VIRT_METHOD_BOX_TYPE: {
- MonoJumpInfoVirtMethod *info1 = data1;
- MonoJumpInfoVirtMethod *info2 = data2;
+ MonoJumpInfoVirtMethod *info1 = (MonoJumpInfoVirtMethod *)data1;
+ MonoJumpInfoVirtMethod *info2 = (MonoJumpInfoVirtMethod *)data2;
return info1->klass == info2->klass && info1->method == info2->method;
}
return MONO_PATCH_INFO_FIELD;
default:
g_assert_not_reached ();
- return -1;
+ return (MonoJumpInfoType)-1;
}
}
static int mrgctx_bytes_alloced = 0;
int size = mono_class_rgctx_get_array_size (n, is_mrgctx) * sizeof (gpointer);
- gpointer array = mono_domain_alloc0 (domain, size);
+ gpointer *array = (gpointer *)mono_domain_alloc0 (domain, size);
if (!inited) {
mono_counters_register ("RGCTX num arrays alloced", MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &rgctx_num_alloced);
}
if (!rgctx [offset + 0])
rgctx [offset + 0] = alloc_rgctx_array (domain, i + 1, method_inst != NULL);
- rgctx = rgctx [offset + 0];
+ rgctx = (void **)rgctx [offset + 0];
first_slot += size - 1;
size = mono_class_rgctx_get_array_size (i + 1, method_inst != NULL);
}
static guint
mrgctx_hash_func (gconstpointer key)
{
- const MonoMethodRuntimeGenericContext *mrgctx = key;
+ const MonoMethodRuntimeGenericContext *mrgctx = (const MonoMethodRuntimeGenericContext *)key;
return mono_aligned_addr_hash (mrgctx->class_vtable) ^ mono_metadata_generic_inst_hash (mrgctx->method_inst);
}
static gboolean
mrgctx_equal_func (gconstpointer a, gconstpointer b)
{
- const MonoMethodRuntimeGenericContext *mrgctx1 = a;
- const MonoMethodRuntimeGenericContext *mrgctx2 = b;
+ const MonoMethodRuntimeGenericContext *mrgctx1 = (const MonoMethodRuntimeGenericContext *)a;
+ const MonoMethodRuntimeGenericContext *mrgctx2 = (const MonoMethodRuntimeGenericContext *)b;
return mrgctx1->class_vtable == mrgctx2->class_vtable &&
mono_metadata_generic_inst_equal (mrgctx1->method_inst, mrgctx2->method_inst);
key.class_vtable = class_vtable;
key.method_inst = method_inst;
- mrgctx = g_hash_table_lookup (domain->method_rgctx_hash, &key);
+ mrgctx = (MonoMethodRuntimeGenericContext *)g_hash_table_lookup (domain->method_rgctx_hash, &key);
if (!mrgctx) {
//int i;
MonoType **type_argv;
int i;
- type_argv = alloca (sizeof (MonoType*) * type_argc);
+ type_argv = (MonoType **)alloca (sizeof (MonoType*) * type_argc);
for (i = 0; i < type_argc; ++i)
type_argv [i] = &mono_defaults.object_class->byval_arg;
}
if (!image->gshared_types [constraint->type])
image->gshared_types [constraint->type] = g_hash_table_new (shared_gparam_hash, shared_gparam_equal);
- res = g_hash_table_lookup (image->gshared_types [constraint->type], &key);
+ res = (MonoType *)g_hash_table_lookup (image->gshared_types [constraint->type], &key);
mono_image_unlock (image);
if (res)
return res;
- copy = mono_image_alloc0 (image, sizeof (MonoGSharedGenericParam));
+ copy = (MonoGSharedGenericParam *)mono_image_alloc0 (image, sizeof (MonoGSharedGenericParam));
memcpy (©->param, par, sizeof (MonoGenericParamFull));
copy->param.info.pklass = NULL;
name = get_shared_gparam_name (constraint->type, ((MonoGenericParamFull*)copy)->info.name);
slot = mono_method_lookup_or_register_info (entry->method, entry->in_mrgctx, entry->data->data.sig, entry->info_type, mono_method_get_context (entry->method));
break;
case MONO_PATCH_INFO_GSHAREDVT_CALL: {
- MonoJumpInfoGSharedVtCall *call_info = g_malloc0 (sizeof (MonoJumpInfoGSharedVtCall)); //mono_domain_alloc0 (domain, sizeof (MonoJumpInfoGSharedVtCall));
+ MonoJumpInfoGSharedVtCall *call_info = (MonoJumpInfoGSharedVtCall *)g_malloc0 (sizeof (MonoJumpInfoGSharedVtCall)); //mono_domain_alloc0 (domain, sizeof (MonoJumpInfoGSharedVtCall));
memcpy (call_info, entry->data->data.gsharedvt, sizeof (MonoJumpInfoGSharedVtCall));
slot = mono_method_lookup_or_register_info (entry->method, entry->in_mrgctx, call_info, entry->info_type, mono_method_get_context (entry->method));
int i;
/* Make a copy into the domain mempool */
- info = g_malloc0 (sizeof (MonoGSharedVtMethodInfo)); //mono_domain_alloc0 (domain, sizeof (MonoGSharedVtMethodInfo));
+ info = (MonoGSharedVtMethodInfo *)g_malloc0 (sizeof (MonoGSharedVtMethodInfo)); //mono_domain_alloc0 (domain, sizeof (MonoGSharedVtMethodInfo));
info->method = oinfo->method;
info->num_entries = oinfo->num_entries;
- info->entries = g_malloc0 (sizeof (MonoRuntimeGenericContextInfoTemplate) * info->num_entries);
+ info->entries = (MonoRuntimeGenericContextInfoTemplate *)g_malloc0 (sizeof (MonoRuntimeGenericContextInfoTemplate) * info->num_entries);
for (i = 0; i < oinfo->num_entries; ++i) {
MonoRuntimeGenericContextInfoTemplate *otemplate = &oinfo->entries [i];
- MonoRuntimeGenericContextInfoTemplate *template = &info->entries [i];
+ MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
- memcpy (template, otemplate, sizeof (MonoRuntimeGenericContextInfoTemplate));
+ memcpy (template_, otemplate, sizeof (MonoRuntimeGenericContextInfoTemplate));
}
slot = mono_method_lookup_or_register_info (entry->method, entry->in_mrgctx, info, entry->info_type, mono_method_get_context (entry->method));
break;
MonoJumpInfoVirtMethod *info;
MonoJumpInfoVirtMethod *oinfo = entry->data->data.virt_method;
- info = g_malloc0 (sizeof (MonoJumpInfoVirtMethod));
+ info = (MonoJumpInfoVirtMethod *)g_malloc0 (sizeof (MonoJumpInfoVirtMethod));
memcpy (info, oinfo, sizeof (MonoJumpInfoVirtMethod));
slot = mono_method_lookup_or_register_info (entry->method, entry->in_mrgctx, info, entry->info_type, mono_method_get_context (entry->method));
break;
static GHashTable *mono_saved_signal_handlers = NULL;
-static gpointer
+static struct sigaction *
get_saved_signal_handler (int signo)
{
if (mono_saved_signal_handlers)
/* The hash is only modified during startup, so no need for locking */
- return g_hash_table_lookup (mono_saved_signal_handlers, GINT_TO_POINTER (signo));
+ return (struct sigaction *)g_hash_table_lookup (mono_saved_signal_handlers, GINT_TO_POINTER (signo));
return NULL;
}
static void
save_old_signal_handler (int signo, struct sigaction *old_action)
{
- struct sigaction *handler_to_save = g_malloc (sizeof (struct sigaction));
+ struct sigaction *handler_to_save = (struct sigaction *)g_malloc (sizeof (struct sigaction));
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_CONFIG,
"Saving old signal handler for signal %d.", signo);
MONO_SIG_HANDLER_SIGNATURE (mono_chain_signal)
{
int signal = MONO_SIG_HANDLER_GET_SIGNO ();
- struct sigaction *saved_handler = get_saved_signal_handler (signal);
+ struct sigaction *saved_handler = (struct sigaction *)get_saved_signal_handler (signal);
if (saved_handler && saved_handler->sa_handler) {
if (!(saved_handler->sa_flags & SA_SIGINFO)) {
MONO_SIG_HANDLER_GET_CONTEXT;
if (mono_thread_internal_current ())
- ji = mono_jit_info_table_find_internal (mono_domain_get (), mono_arch_ip_from_context (ctx), TRUE, TRUE);
+ ji = mono_jit_info_table_find_internal (mono_domain_get (), (char *)mono_arch_ip_from_context (ctx), TRUE, TRUE);
if (!ji) {
if (mono_chain_signal (MONO_SIG_HANDLER_PARAMS))
return;
MonoProfilerCallChainStrategy call_chain_strategy = mono_profiler_stat_get_call_chain_strategy ();
if (call_chain_depth == 0) {
- mono_profiler_stat_hit (mono_arch_ip_from_context (ctx), ctx);
+ mono_profiler_stat_hit ((guchar *)mono_arch_ip_from_context (ctx), ctx);
} else {
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
int current_frame_index = 1;
MonoContext mono_context;
guchar *ips [call_chain_depth + 1];
mono_sigctx_to_monoctx (ctx, &mono_context);
- ips [0] = MONO_CONTEXT_GET_IP (&mono_context);
+ ips [0] = (guchar *)MONO_CONTEXT_GET_IP (&mono_context);
if (jit_tls != NULL) {
if (call_chain_strategy == MONO_PROFILER_CALL_CHAIN_NATIVE) {
guchar *stack_bottom;
guchar *stack_top;
- stack_bottom = jit_tls->end_of_stack;
- stack_top = MONO_CONTEXT_GET_SP (&mono_context);
- current_frame = MONO_CONTEXT_GET_BP (&mono_context);
+ stack_bottom = (guchar *)jit_tls->end_of_stack;
+ stack_top = (guchar *)MONO_CONTEXT_GET_SP (&mono_context);
+ current_frame = (guchar *)MONO_CONTEXT_GET_BP (&mono_context);
while ((current_frame_index <= call_chain_depth) &&
(stack_bottom IS_BEFORE_ON_STACK (guchar*) current_frame) &&
((guchar*) current_frame IS_BEFORE_ON_STACK stack_top)) {
- ips [current_frame_index] = CURRENT_FRAME_GET_RETURN_ADDRESS (current_frame);
+ ips [current_frame_index] = (guchar *)CURRENT_FRAME_GET_RETURN_ADDRESS (current_frame);
current_frame_index ++;
stack_top = current_frame;
- current_frame = CURRENT_FRAME_GET_BASE_POINTER (current_frame);
+ current_frame = (guchar *)CURRENT_FRAME_GET_BASE_POINTER (current_frame);
}
#else
call_chain_strategy = MONO_PROFILER_CALL_CHAIN_GLIBC;
ji = mono_find_jit_info (domain, jit_tls, &res, NULL, &mono_context,
&new_mono_context, NULL, &lmf, &native_offset, NULL);
while ((ji != NULL) && (current_frame_index <= call_chain_depth)) {
- ips [current_frame_index] = MONO_CONTEXT_GET_IP (&new_mono_context);
+ ips [current_frame_index] = (guchar *)MONO_CONTEXT_GET_IP (&new_mono_context);
current_frame_index ++;
mono_context = new_mono_context;
ji = mono_find_jit_info (domain, jit_tls, &res, NULL, &mono_context,
struct sigaction previous_sa;
#ifdef MONO_ARCH_USE_SIGACTION
- sa.sa_sigaction = handler;
+ sa.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
sigemptyset (&sa.sa_mask);
sa.sa_flags = SA_SIGINFO;
#ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
const char *argv [9];
- char template [] = "/tmp/mono-lldb-commands.XXXXXX";
+ char template_ [] = "/tmp/mono-lldb-commands.XXXXXX";
char buf1 [128];
FILE *commands;
gboolean using_lldb = FALSE;
return;
if (using_lldb) {
- if (mkstemp (template) == -1)
+ if (mkstemp (template_) == -1)
return;
- commands = fopen (template, "w");
+ commands = fopen (template_, "w");
fprintf (commands, "process attach --pid %ld\n", (long) crashed_pid);
fprintf (commands, "thread list\n");
fclose (commands);
argv [1] = "--source";
- argv [2] = template;
+ argv [2] = template_;
argv [3] = 0;
} else {
argv [1] = "-ex";
execv (argv [0], (char**)argv);
if (using_lldb)
- unlink (template);
+ unlink (template_);
}
#endif
#endif /* __native_client__ */
* r12.
*/
guint8*
-mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target)
+mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, MonoJumpInfoType tramp_type, gconstpointer target)
{
/* Load the mscorlib got address */
ppc_ldptr (code, ppc_r12, sizeof (gpointer), ppc_r30);
if (!domain)
domain = mono_get_root_domain ();
- ji = mono_jit_info_table_find_internal (domain, ip, TRUE, TRUE);
+ ji = mono_jit_info_table_find_internal (domain, (char *)ip, TRUE, TRUE);
if (!ji) {
user_data.ip = ip;
user_data.method = NULL;
MonoGenericSharingContext*gsctx;
const char *shared_type;
- ji = mini_jit_info_table_find_ext (domain, ip, TRUE, &target_domain);
+ ji = mini_jit_info_table_find_ext (domain, (char *)ip, TRUE, &target_domain);
if (ji && ji->is_trampoline) {
- MonoTrampInfo *tinfo = ji->d.tramp_info;
+ MonoTrampInfo *tinfo = (MonoTrampInfo *)ji->d.tramp_info;
printf ("IP %p is at offset 0x%x of trampoline '%s'.\n", ip, (int)((guint8*)ip - tinfo->code), tinfo->name);
return;
MonoJumpInfoToken *
mono_jump_info_token_new2 (MonoMemPool *mp, MonoImage *image, guint32 token, MonoGenericContext *context)
{
- MonoJumpInfoToken *res = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoToken));
+ MonoJumpInfoToken *res = (MonoJumpInfoToken *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoToken));
res->image = image;
res->token = token;
res->has_context = context != NULL;
{
MonoJitInfo *ji;
- ji = mono_domain_alloc0 (domain, mono_jit_info_size (0, 0, 0));
- mono_jit_info_init (ji, NULL, info->code, info->code_size, 0, 0, 0);
+ ji = (MonoJitInfo *)mono_domain_alloc0 (domain, mono_jit_info_size ((MonoJitInfoFlags)0, 0, 0));
+ mono_jit_info_init (ji, NULL, info->code, info->code_size, (MonoJitInfoFlags)0, 0, 0);
ji->d.tramp_info = info;
ji->is_trampoline = TRUE;
GSList *l;
for (l = tramp_infos; l; l = l->next) {
- MonoTrampInfo *info = l->data;
+ MonoTrampInfo *info = (MonoTrampInfo *)l->data;
mono_tramp_info_free (info);
}
GSList *l;
for (l = tramp_infos; l; l = l->next) {
- MonoTrampInfo *info = l->data;
+ MonoTrampInfo *info = (MonoTrampInfo *)l->data;
register_trampoline_jit_info (domain, info);
}
MonoJitDynamicMethodInfo *res;
if (domain_jit_info (domain)->dynamic_code_hash)
- res = g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method);
+ res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method);
else
res = NULL;
return res;
mono_get_lmf (void)
{
#if defined(MONO_HAVE_FAST_TLS) && defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
- return MONO_FAST_TLS_GET (mono_lmf);
+ return (MonoLMF *)MONO_FAST_TLS_GET (mono_lmf);
#else
MonoJitTlsData *jit_tls;
mono_get_lmf_addr (void)
{
#ifdef MONO_HAVE_FAST_TLS
- return MONO_FAST_TLS_GET (mono_lmf_addr);
+ return (MonoLMF **)MONO_FAST_TLS_GET (mono_lmf_addr);
#else
MonoJitTlsData *jit_tls;
MonoJitTlsData*
mono_get_jit_tls (void)
{
- return mono_native_tls_get_value (mono_jit_tls_id);
+ return (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
}
static void
MonoJitTlsData *jit_tls;
MonoLMF *lmf;
- jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
if (jit_tls)
return jit_tls;
jit_tls = g_new0 (MonoJitTlsData, 1);
- jit_tls->abort_func = abort_func;
+ jit_tls->abort_func = (void (*)(MonoObject *))abort_func;
jit_tls->end_of_stack = stack_start;
mono_set_jit_tls (jit_tls);
* The current offender is mono_thread_manage which cleanup threads from the outside.
*/
if (info && mono_thread_info_get_tid (info) == tid) {
- jit_tls = info->jit_data;
+ jit_tls = (MonoJitTlsData *)info->jit_data;
info->jit_data = NULL;
mono_set_jit_tls (NULL);
} else {
info = mono_thread_info_lookup (tid);
if (info) {
- jit_tls = info->jit_data;
+ jit_tls = (MonoJitTlsData *)info->jit_data;
info->jit_data = NULL;
}
mono_hazard_pointer_clear (mono_hazard_pointer_get (), 1);
MonoJumpInfo*
mono_patch_info_dup_mp (MonoMemPool *mp, MonoJumpInfo *patch_info)
{
- MonoJumpInfo *res = mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
+ MonoJumpInfo *res = (MonoJumpInfo *)mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
memcpy (res, patch_info, sizeof (MonoJumpInfo));
switch (patch_info->type) {
case MONO_PATCH_INFO_TYPE_FROM_HANDLE:
case MONO_PATCH_INFO_LDTOKEN:
case MONO_PATCH_INFO_DECLSEC:
- res->data.token = mono_mempool_alloc (mp, sizeof (MonoJumpInfoToken));
+ res->data.token = (MonoJumpInfoToken *)mono_mempool_alloc (mp, sizeof (MonoJumpInfoToken));
memcpy (res->data.token, patch_info->data.token, sizeof (MonoJumpInfoToken));
break;
case MONO_PATCH_INFO_SWITCH:
- res->data.table = mono_mempool_alloc (mp, sizeof (MonoJumpInfoBBTable));
+ res->data.table = (MonoJumpInfoBBTable *)mono_mempool_alloc (mp, sizeof (MonoJumpInfoBBTable));
memcpy (res->data.table, patch_info->data.table, sizeof (MonoJumpInfoBBTable));
- res->data.table->table = mono_mempool_alloc (mp, sizeof (MonoBasicBlock*) * patch_info->data.table->table_size);
+ res->data.table->table = (MonoBasicBlock **)mono_mempool_alloc (mp, sizeof (MonoBasicBlock*) * patch_info->data.table->table_size);
memcpy (res->data.table->table, patch_info->data.table->table, sizeof (MonoBasicBlock*) * patch_info->data.table->table_size);
break;
case MONO_PATCH_INFO_RGCTX_FETCH:
case MONO_PATCH_INFO_RGCTX_SLOT_INDEX:
- res->data.rgctx_entry = mono_mempool_alloc (mp, sizeof (MonoJumpInfoRgctxEntry));
+ res->data.rgctx_entry = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc (mp, sizeof (MonoJumpInfoRgctxEntry));
memcpy (res->data.rgctx_entry, patch_info->data.rgctx_entry, sizeof (MonoJumpInfoRgctxEntry));
res->data.rgctx_entry->data = mono_patch_info_dup_mp (mp, res->data.rgctx_entry->data);
break;
case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE:
- res->data.del_tramp = mono_mempool_alloc0 (mp, sizeof (MonoDelegateClassMethodPair));
+ res->data.del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (mp, sizeof (MonoDelegateClassMethodPair));
memcpy (res->data.del_tramp, patch_info->data.del_tramp, sizeof (MonoDelegateClassMethodPair));
break;
case MONO_PATCH_INFO_GSHAREDVT_CALL:
- res->data.gsharedvt = mono_mempool_alloc (mp, sizeof (MonoJumpInfoGSharedVtCall));
+ res->data.gsharedvt = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc (mp, sizeof (MonoJumpInfoGSharedVtCall));
memcpy (res->data.gsharedvt, patch_info->data.gsharedvt, sizeof (MonoJumpInfoGSharedVtCall));
break;
case MONO_PATCH_INFO_GSHAREDVT_METHOD: {
int i;
oinfo = patch_info->data.gsharedvt_method;
- info = mono_mempool_alloc (mp, sizeof (MonoGSharedVtMethodInfo));
+ info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc (mp, sizeof (MonoGSharedVtMethodInfo));
res->data.gsharedvt_method = info;
memcpy (info, oinfo, sizeof (MonoGSharedVtMethodInfo));
- info->entries = mono_mempool_alloc (mp, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
+ info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc (mp, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
for (i = 0; i < oinfo->num_entries; ++i) {
MonoRuntimeGenericContextInfoTemplate *otemplate = &oinfo->entries [i];
- MonoRuntimeGenericContextInfoTemplate *template = &info->entries [i];
+ MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
- memcpy (template, otemplate, sizeof (MonoRuntimeGenericContextInfoTemplate));
+ memcpy (template_, otemplate, sizeof (MonoRuntimeGenericContextInfoTemplate));
}
//info->locals_types = mono_mempool_alloc0 (mp, info->nlocals * sizeof (MonoType*));
//memcpy (info->locals_types, oinfo->locals_types, info->nlocals * sizeof (MonoType*));
MonoJumpInfoVirtMethod *oinfo;
oinfo = patch_info->data.virt_method;
- info = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoVirtMethod));
+ info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoVirtMethod));
res->data.virt_method = info;
memcpy (info, oinfo, sizeof (MonoJumpInfoVirtMethod));
break;
jump_table = g_malloc0 (sizeof(gpointer) * patch_info->data.table->table_size);
#else
if (method && method->dynamic) {
- jump_table = mono_code_manager_reserve (mono_dynamic_code_hash_lookup (domain, method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
+ jump_table = (void **)mono_code_manager_reserve (mono_dynamic_code_hash_lookup (domain, method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
} else {
if (mono_aot_only) {
- jump_table = mono_domain_alloc (domain, sizeof (gpointer) * patch_info->data.table->table_size);
+ jump_table = (void **)mono_domain_alloc (domain, sizeof (gpointer) * patch_info->data.table->table_size);
} else {
- jump_table = mono_domain_code_reserve (domain, sizeof (gpointer) * patch_info->data.table->table_size);
+ jump_table = (void **)mono_domain_code_reserve (domain, sizeof (gpointer) * patch_info->data.table->table_size);
}
}
#endif
if (!mono_error_ok (&error))
g_error ("Could not patch ldtoken due to %s", mono_error_get_message (&error));
mono_class_init (handle_class);
- mono_class_init (mono_class_from_mono_type (handle));
+ mono_class_init (mono_class_from_mono_type ((MonoType *)handle));
target =
- mono_type_get_object (domain, handle);
+ mono_type_get_object (domain, (MonoType *)handle);
break;
}
case MONO_PATCH_INFO_LDTOKEN: {
case MONO_PATCH_INFO_TLS_OFFSET: {
int offset;
- offset = mini_get_tls_offset (GPOINTER_TO_INT (patch_info->data.target));
+ offset = mini_get_tls_offset ((MonoTlsKey)GPOINTER_TO_INT (patch_info->data.target));
#ifdef MONO_ARCH_HAVE_TRANSLATE_TLS_OFFSET
offset = mono_arch_translate_tls_offset (offset);
#endif
int len;
char *s;
- len = strlen (patch_info->data.target);
- s = mono_domain_alloc0 (domain, len + 1);
+ len = strlen ((const char *)patch_info->data.target);
+ s = (char *)mono_domain_alloc0 (domain, len + 1);
memcpy (s, patch_info->data.target, len);
target = s;
static int failed_lookups = 0;
mono_domain_jit_code_hash_lock (domain);
- ji = mono_internal_hash_table_lookup (&domain->jit_code_hash, method);
+ ji = (MonoJitInfo *)mono_internal_hash_table_lookup (&domain->jit_code_hash, method);
if (!ji && shared) {
/* Try generic sharing */
- ji = mono_internal_hash_table_lookup (&domain->jit_code_hash, shared);
+ ji = (MonoJitInfo *)mono_internal_hash_table_lookup (&domain->jit_code_hash, shared);
if (ji && !ji->has_generic_jit_info)
ji = NULL;
if (!inited) {
/*
* SGEN requires the JIT info for these methods to be registered, see is_ip_in_managed_allocator ().
*/
- ji = mini_jit_info_table_find (mono_domain_get (), code, &d);
+ ji = mini_jit_info_table_find (mono_domain_get (), (char *)code, &d);
g_assert (ji);
}
remove = NULL;
for (tmp = jlist->list; tmp; tmp = tmp->next) {
- guint8 *ip = tmp->data;
+ guint8 *ip = (guint8 *)tmp->data;
if (ip >= (guint8*)ji->ji->code_start && ip < (guint8*)ji->ji->code_start + ji->ji->code_size)
remove = g_slist_prepend (remove, tmp);
}
for (tmp = remove; tmp; tmp = tmp->next) {
- jlist->list = g_slist_delete_link (jlist->list, tmp->data);
+ jlist->list = g_slist_delete_link ((GSList *)jlist->list, (GSList *)tmp->data);
}
g_slist_free (remove);
}
domain_info = domain_jit_info (domain);
- info = mono_conc_hashtable_lookup (domain_info->runtime_invoke_hash, method);
+ info = (RuntimeInvokeInfo *)mono_conc_hashtable_lookup (domain_info->runtime_invoke_hash, method);
if (!info) {
if (mono_security_core_clr_enabled ()) {
info->runtime_invoke = mono_jit_compile_method (invoke);
mono_domain_lock (domain);
- info2 = mono_conc_hashtable_insert (domain_info->runtime_invoke_hash, method, info);
+ info2 = (RuntimeInvokeInfo *)mono_conc_hashtable_insert (domain_info->runtime_invoke_hash, method, info);
mono_domain_unlock (domain);
if (info2) {
g_free (info);
}
}
- runtime_invoke = info->runtime_invoke;
+ runtime_invoke = (MonoObject *(*)(MonoObject *, void **, MonoObject **, void *))info->runtime_invoke;
/*
* We need this here because mono_marshal_get_runtime_invoke can place
if (!dyn_runtime_invoke) {
invoke = mono_marshal_get_runtime_invoke_dynamic ();
- dyn_runtime_invoke = mono_jit_compile_method (invoke);
+ dyn_runtime_invoke = (RuntimeInvokeDynamicFunction)mono_jit_compile_method (invoke);
}
/* Convert the arguments to the format expected by start_dyn_call () */
- args = g_alloca ((sig->param_count + sig->hasthis + info->needs_rgctx) * sizeof (gpointer));
+ args = (void **)g_alloca ((sig->param_count + sig->hasthis + info->needs_rgctx) * sizeof (gpointer));
pindex = 0;
if (sig->hasthis)
args [pindex ++] = &obj;
gpointer *args;
int i, pindex;
- args = g_alloca ((sig->param_count + sig->hasthis + info->needs_rgctx) * sizeof (gpointer));
+ args = (void **)g_alloca ((sig->param_count + sig->hasthis + info->needs_rgctx) * sizeof (gpointer));
pindex = 0;
rgctx = mini_method_get_rgctx (method);
for (i = 0; i < sig->param_count; ++i)
args [pindex ++] = params [i];
args [pindex ++] = &rgctx;
- return runtime_invoke (obj, args, exc, info->compiled_method);
+ return runtime_invoke ((MonoObject *)obj, args, exc, info->compiled_method);
} else {
- return runtime_invoke (obj, params, exc, info->compiled_method);
+ return runtime_invoke ((MonoObject *)obj, params, exc, info->compiled_method);
}
}
MONO_SIG_HANDLER_INFO_TYPE *info = MONO_SIG_HANDLER_GET_INFO ();
MONO_SIG_HANDLER_GET_CONTEXT;
- ji = mono_jit_info_table_find_internal (mono_domain_get (), mono_arch_ip_from_context (ctx), TRUE, TRUE);
+ ji = mono_jit_info_table_find_internal (mono_domain_get (), (char *)mono_arch_ip_from_context (ctx), TRUE, TRUE);
#if defined(MONO_ARCH_HAVE_IS_INT_OVERFLOW)
if (mono_arch_is_int_overflow (ctx, info))
MONO_SIG_HANDLER_FUNC (, mono_sigsegv_signal_handler)
{
MonoJitInfo *ji;
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
gpointer fault_addr = NULL;
#ifdef HAVE_SIG_INFO
MONO_SIG_HANDLER_INFO_TYPE *info = MONO_SIG_HANDLER_GET_INFO ();
}
#endif
- ji = mono_jit_info_table_find_internal (mono_domain_get (), mono_arch_ip_from_context (ctx), TRUE, TRUE);
+ ji = mono_jit_info_table_find_internal (mono_domain_get (), (char *)mono_arch_ip_from_context (ctx), TRUE, TRUE);
#ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
if (mono_handle_soft_stack_ovf (jit_tls, ji, ctx, info, (guint8*)info->si_addr))
if ((method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
(mono_method_signature (method)->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))) {
nm = mono_marshal_get_remoting_invoke_for_target (method, target);
- addr = mono_compile_method (nm);
+ addr = (guint8 *)mono_compile_method (nm);
} else
{
- addr = mono_compile_method (method);
+ addr = (guint8 *)mono_compile_method (method);
}
return mono_get_addr_from_ftnptr (addr);
}
memcpy (new_table, vtable_trampolines, vtable_trampolines_size * sizeof (gpointer));
g_free (vtable_trampolines);
mono_memory_barrier ();
- vtable_trampolines = new_table;
+ vtable_trampolines = (void **)new_table;
vtable_trampolines_size = new_size;
}
mono_jit_unlock ();
int ind = (load_imt_reg ? (-offset) : offset) / SIZEOF_VOID_P;
sprintf (tramp_name, "delegate_virtual_invoke%s_%d", imt, ind);
- cache [idx] = mono_aot_get_trampoline (tramp_name);
+ cache [idx] = (guint8 *)mono_aot_get_trampoline (tramp_name);
g_assert (cache [idx]);
} else {
- cache [idx] = mono_arch_get_delegate_virtual_invoke_impl (sig, method, offset, load_imt_reg);
+ cache [idx] = (guint8 *)mono_arch_get_delegate_virtual_invoke_impl (sig, method, offset, load_imt_reg);
}
return cache [idx];
}
static gint
class_method_pair_equal (gconstpointer ka, gconstpointer kb)
{
- const MonoClassMethodPair *apair = ka;
- const MonoClassMethodPair *bpair = kb;
+ const MonoClassMethodPair *apair = (const MonoClassMethodPair *)ka;
+ const MonoClassMethodPair *bpair = (const MonoClassMethodPair *)kb;
return apair->klass == bpair->klass && apair->method == bpair->method ? 1 : 0;
}
static guint
class_method_pair_hash (gconstpointer data)
{
- const MonoClassMethodPair *pair = data;
+ const MonoClassMethodPair *pair = (const MonoClassMethodPair *)data;
return (gsize)pair->klass ^ (gsize)pair->method;
}
static void
delete_jump_list (gpointer key, gpointer value, gpointer user_data)
{
- MonoJumpList *jlist = value;
+ MonoJumpList *jlist = (MonoJumpList *)value;
g_slist_free (jlist->list);
}
static void
delete_got_slot_list (gpointer key, gpointer value, gpointer user_data)
{
- GSList *list = value;
+ GSList *list = (GSList *)value;
g_slist_free (list);
}
static void
dynamic_method_info_free (gpointer key, gpointer value, gpointer user_data)
{
- MonoJitDynamicMethodInfo *di = value;
+ MonoJitDynamicMethodInfo *di = (MonoJitDynamicMethodInfo *)value;
mono_code_manager_destroy (di->code_mp);
g_free (di);
}
mono_runtime_cleanup (domain);
#endif
- free_jit_tls_data (mono_native_tls_get_value (mono_jit_tls_id));
+ free_jit_tls_data ((MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id));
mono_icall_cleanup ();
static gint
rgctx_tramp_info_equal (gconstpointer ka, gconstpointer kb)
{
- const RgctxTrampInfo *i1 = ka;
- const RgctxTrampInfo *i2 = kb;
+ const RgctxTrampInfo *i1 = (const RgctxTrampInfo *)ka;
+ const RgctxTrampInfo *i2 = (const RgctxTrampInfo *)kb;
if (i1->m == i2->m && i1->addr == i2->addr)
return 1;
static guint
rgctx_tramp_info_hash (gconstpointer data)
{
- const RgctxTrampInfo *info = data;
+ const RgctxTrampInfo *info = (const RgctxTrampInfo *)data;
return GPOINTER_TO_UINT (info->m) ^ GPOINTER_TO_UINT (info->addr);
}
if (mono_aot_only)
res = mono_aot_get_static_rgctx_trampoline (ctx, addr);
else
- res = mono_arch_get_static_rgctx_trampoline (m, ctx, addr);
+ res = mono_arch_get_static_rgctx_trampoline (m, (MonoMethodRuntimeGenericContext *)ctx, addr);
mono_domain_lock (domain);
/* Duplicates inserted while we didn't hold the lock are OK */
- info = mono_domain_alloc (domain, sizeof (RgctxTrampInfo));
+ info = (RgctxTrampInfo *)mono_domain_alloc (domain, sizeof (RgctxTrampInfo));
info->m = m;
info->addr = addr;
g_hash_table_insert (domain_jit_info (domain)->static_rgctx_trampoline_hash, info, res);
/* This has to be variance aware since imt_method can be from an interface that vt->klass doesn't directly implement */
interface_offset = mono_class_interface_offset_with_variance (vt->klass, imt_method->klass, &variance_used);
if (interface_offset < 0)
- g_error ("%s doesn't implement interface %s\n", mono_type_get_name_full (&vt->klass->byval_arg, 0), mono_type_get_name_full (&imt_method->klass->byval_arg, 0));
+ g_error ("%s doesn't implement interface %s\n", mono_type_get_name_full (&vt->klass->byval_arg, MONO_TYPE_NAME_FORMAT_IL), mono_type_get_name_full (&imt_method->klass->byval_arg, MONO_TYPE_NAME_FORMAT_IL));
*variant_iface = NULL;
if (imt_method->is_inflated && ((MonoMethodInflated*)imt_method)->context.method_inst) {
} else {
/* Avoid loading metadata or creating a generic vtable if possible */
if (lookup_aot && !vt->klass->valuetype)
- aot_addr = mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, interface_offset + mono_method_get_vtable_slot (imt_method));
+ aot_addr = (guint8 *)mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, interface_offset + mono_method_get_vtable_slot (imt_method));
else
aot_addr = NULL;
if (aot_addr)
MonoJitInfo *ji;
// FIXME: This loads information from AOT (perf problem)
- ji = mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (compiled_method), NULL);
+ ji = mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
callee_gsharedvt = mini_jit_info_is_gsharedvt (ji);
callee_array_helper = FALSE;
MonoMethod *declaring = NULL;
MonoMethod *generic_virtual = NULL, *variant_iface = NULL;
int context_used;
- gboolean imt_call, virtual;
+ gboolean imt_call, virtual_;
gpointer *orig_vtable_slot, *vtable_slot_to_patch = NULL;
MonoJitInfo *ji = NULL;
- virtual = vt && (gpointer)vtable_slot > (gpointer)vt;
+ virtual_ = vt && (gpointer)vtable_slot > (gpointer)vt;
imt_call = vt && (gpointer)vtable_slot < (gpointer)vt;
/*
* rgctx trampolines are needed when the call is indirect so the caller can't pass
* the rgctx argument needed by the callee.
*/
- if (virtual && m)
+ if (virtual_ && m)
need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (m, FALSE);
orig_vtable_slot = vtable_slot;
g_assert (vtable_slot);
imt_method = mono_arch_find_imt_method (regs, code);
- this_arg = mono_arch_get_this_arg_from_call (regs, code);
+ this_arg = (MonoObject *)mono_arch_get_this_arg_from_call (regs, code);
if (mono_object_is_transparent_proxy (this_arg)) {
/* Use the slow path for now */
* The virtual check is needed because is_generic_method_definition (m) could
* return TRUE for methods used in IMT calls too.
*/
- if (virtual && is_generic_method_definition (m)) {
+ if (virtual_ && is_generic_method_definition (m)) {
MonoError error;
MonoGenericContext context = { NULL, NULL };
MonoMethod *declaring;
klass = vtable->klass;
} else {
- MonoObject *this_argument = mono_arch_get_this_arg_from_call (regs, code);
+ MonoObject *this_argument = (MonoObject *)mono_arch_get_this_arg_from_call (regs, code);
vt = this_argument->vtable;
vtable_slot = orig_vtable_slot;
GSList *list, *tmp;
mono_domain_lock (domain);
- list = g_hash_table_lookup (domain_jit_info (domain)->jump_target_got_slot_hash, m);
+ list = (GSList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_got_slot_hash, m);
if (list) {
for (tmp = list; tmp; tmp = tmp->next) {
- gpointer *got_slot = tmp->data;
+ gpointer *got_slot = (gpointer *)tmp->data;
*got_slot = addr;
}
g_hash_table_remove (domain_jit_info (domain)->jump_target_got_slot_hash, m);
if (plt_entry) {
if (generic_shared) {
target_ji =
- mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (compiled_method), NULL);
+ mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
if (!ji)
ji = mini_jit_info_table_find (mono_domain_get (), (char*)code, NULL);
}
}
if (!no_patch)
- mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, addr);
+ mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, (guint8 *)addr);
} else {
if (generic_shared) {
if (m->wrapper_type != MONO_WRAPPER_NONE)
/* Patch calling code */
target_ji =
- mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (compiled_method), NULL);
+ mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
if (!ji)
ji = mini_jit_info_table_find (mono_domain_get (), (char*)code, NULL);
}
if (!no_patch && mono_method_same_domain (ji, target_ji))
- mono_arch_patch_callsite (ji->code_start, code, addr);
+ mono_arch_patch_callsite ((guint8 *)ji->code_start, code, (guint8 *)addr);
}
}
{
trampoline_calls ++;
- return common_call_trampoline (regs, code, arg, NULL, NULL);
+ return common_call_trampoline (regs, code, (MonoMethod *)arg, NULL, NULL);
}
/**
/*
* Obtain the vtable from the 'this' arg.
*/
- this_arg = mono_arch_get_this_arg_from_call (regs, code);
+ this_arg = (MonoObject *)mono_arch_get_this_arg_from_call (regs, code);
g_assert (this_arg);
vt = this_arg->vtable;
trampoline_calls ++;
- image = *(gpointer*)(gpointer)token_info;
+ image = (MonoImage *)*(gpointer*)(gpointer)token_info;
token_info += sizeof (gpointer);
token = *(guint32*)(gpointer)token_info;
plt_entry = mono_aot_get_plt_entry (code);
g_assert (plt_entry);
- mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, addr);
+ mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, (guint8 *)addr);
return addr;
}
num_lookups++;
if (mrgctx)
- return mono_method_fill_runtime_generic_context (arg, index);
+ return mono_method_fill_runtime_generic_context ((MonoMethodRuntimeGenericContext *)arg, index);
else
- return mono_class_fill_runtime_generic_context (arg, index);
+ return mono_class_fill_runtime_generic_context ((MonoVTable *)arg, index);
}
/*
invoke = mono_get_delegate_invoke (klass);
g_assert (invoke);
- tramp_data = mono_domain_alloc0 (domain, sizeof (MonoDelegateTrampInfo));
+ tramp_data = (MonoDelegateTrampInfo *)mono_domain_alloc0 (domain, sizeof (MonoDelegateTrampInfo));
tramp_data->invoke = invoke;
tramp_data->invoke_sig = mono_method_signature (invoke);
tramp_data->impl_this = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), TRUE);
gboolean enable_caching = TRUE;
MonoDelegateTrampInfo *tramp_info = (MonoDelegateTrampInfo*)arg;
MonoMethod *invoke = tramp_info->invoke;
- guint8 *impl_this = tramp_info->impl_this;
- guint8 *impl_nothis = tramp_info->impl_nothis;
+ guint8 *impl_this = (guint8 *)tramp_info->impl_this;
+ guint8 *impl_nothis = (guint8 *)tramp_info->impl_nothis;
MonoError err;
MonoMethodSignature *sig;
gpointer addr, compiled_method;
trampoline_calls ++;
/* Obtain the delegate object according to the calling convention */
- delegate = mono_arch_get_this_arg_from_call (regs, code);
+ delegate = (MonoDelegate *)mono_arch_get_this_arg_from_call (regs, code);
g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class));
if (delegate->method) {
// ftnptrs are being used. "method" would end up null on archtitectures without
// ftnptrs so we can just skip this.
} else if (delegate->method_ptr) {
- ji = mono_jit_info_table_find (domain, mono_get_addr_from_ftnptr (delegate->method_ptr));
+ ji = mono_jit_info_table_find (domain, (char *)mono_get_addr_from_ftnptr (delegate->method_ptr));
if (ji)
method = jinfo_get_method (ji);
}
addr = mini_add_method_trampoline (method, compiled_method, need_rgctx_tramp, need_unbox_tramp);
delegate->method_ptr = addr;
if (enable_caching && delegate->method_code)
- *delegate->method_code = delegate->method_ptr;
+ *delegate->method_code = (guint8 *)delegate->method_ptr;
}
} else {
if (need_rgctx_tramp)
if (!code) {
/* The general, unoptimized case */
m = mono_marshal_get_delegate_invoke (invoke, delegate);
- code = mono_compile_method (m);
- code = mini_add_method_trampoline (m, code, mono_method_needs_static_rgctx_invoke (m, FALSE), FALSE);
+ code = (guint8 *)mono_compile_method (m);
+ code = (guint8 *)mini_add_method_trampoline (m, code, mono_method_needs_static_rgctx_invoke (m, FALSE), FALSE);
}
delegate->invoke_impl = mono_get_addr_from_ftnptr (code);
{
MonoContext ctx;
MonoException *exc;
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
gpointer resume_ip = jit_tls->handler_block_return_address;
memcpy (&ctx, &jit_tls->handler_block_context, sizeof (MonoContext));
exc = mono_thread_resume_interruption ();
if (exc) {
- mono_handle_exception (&ctx, exc);
+ mono_handle_exception (&ctx, (MonoObject *)exc);
mono_restore_context (&ctx);
}
code = mono_create_specific_trampoline (method, MONO_TRAMPOLINE_JUMP, mono_domain_get (), &code_size);
g_assert (code_size);
- ji = mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO);
+ ji = (MonoJitInfo *)mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO);
ji->code_start = code;
ji->code_size = code_size;
ji->d.method = method;
MonoDomain *domain = mono_domain_get ();
guint8 *buf, *start;
- buf = start = mono_domain_alloc0 (domain, 2 * sizeof (gpointer));
+ buf = start = (guint8 *)mono_domain_alloc0 (domain, 2 * sizeof (gpointer));
*(gpointer*)(gpointer)buf = image;
buf += sizeof (gpointer);
pair.klass = klass;
pair.method = method;
mono_domain_lock (domain);
- tramp_info = g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, &pair);
+ tramp_info = (MonoDelegateTrampInfo *)g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, &pair);
mono_domain_unlock (domain);
if (tramp_info)
return tramp_info;
tramp_info->invoke_impl = mono_create_specific_trampoline (tramp_info, MONO_TRAMPOLINE_DELEGATE, domain, &code_size);
g_assert (code_size);
- dpair = mono_domain_alloc0 (domain, sizeof (MonoClassMethodPair));
+ dpair = (MonoClassMethodPair *)mono_domain_alloc0 (domain, sizeof (MonoClassMethodPair));
memcpy (dpair, &pair, sizeof (MonoClassMethodPair));
/* store trampoline address */
* EAX.
*/
guint8*
-mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target)
+mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, MonoJumpInfoType tramp_type, gconstpointer target)
{
/* Load the mscorlib got address */
x86_mov_reg_membase (code, X86_EAX, MONO_ARCH_GOT_REG, sizeof (gpointer), 4);
void
mono_emit_unwind_op (MonoCompile *cfg, int when, int tag, int reg, int val)
{
- MonoUnwindOp *op = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoUnwindOp));
+ MonoUnwindOp *op = (MonoUnwindOp *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoUnwindOp));
op->op = tag;
op->reg = reg;
{
region = mono_get_block_region_notry (cfg, region);
- return g_hash_table_lookup (cfg->spvars, GINT_TO_POINTER (region));
+ return (MonoInst *)g_hash_table_lookup (cfg->spvars, GINT_TO_POINTER (region));
}
static void
while (vreg >= cfg->vreg_to_inst_len)
cfg->vreg_to_inst_len = cfg->vreg_to_inst_len ? cfg->vreg_to_inst_len * 2 : 32;
- cfg->vreg_to_inst = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * cfg->vreg_to_inst_len);
+ cfg->vreg_to_inst = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * cfg->vreg_to_inst_len);
if (size)
memcpy (cfg->vreg_to_inst, tmp, size * sizeof (MonoInst*));
}
while (vreg >= cfg->vreg_is_ref_len)
cfg->vreg_is_ref_len = cfg->vreg_is_ref_len ? cfg->vreg_is_ref_len * 2 : 32;
- cfg->vreg_is_ref = mono_mempool_alloc0 (cfg->mempool, sizeof (gboolean) * cfg->vreg_is_ref_len);
+ cfg->vreg_is_ref = (gboolean *)mono_mempool_alloc0 (cfg->mempool, sizeof (gboolean) * cfg->vreg_is_ref_len);
if (size)
memcpy (cfg->vreg_is_ref, tmp, size * sizeof (gboolean));
}
while (vreg >= cfg->vreg_is_mp_len)
cfg->vreg_is_mp_len = cfg->vreg_is_mp_len ? cfg->vreg_is_mp_len * 2 : 32;
- cfg->vreg_is_mp = mono_mempool_alloc0 (cfg->mempool, sizeof (gboolean) * cfg->vreg_is_mp_len);
+ cfg->vreg_is_mp = (gboolean *)mono_mempool_alloc0 (cfg->mempool, sizeof (gboolean) * cfg->vreg_is_mp_len);
if (size)
memcpy (cfg->vreg_is_mp, tmp, size * sizeof (gboolean));
}
void
mono_create_jump_table (MonoCompile *cfg, MonoInst *label, MonoBasicBlock **bbs, int num_blocks)
{
- MonoJumpInfo *ji = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfo));
+ MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfo));
MonoJumpInfoBBTable *table;
- table = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
+ table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
table->table = bbs;
table->table_size = num_blocks;
if (!sighash) {
sighash = g_hash_table_new (NULL, NULL);
}
- else if ((res = g_hash_table_lookup (sighash, GINT_TO_POINTER (arity)))) {
+ else if ((res = (MonoMethodSignature *)g_hash_table_lookup (sighash, GINT_TO_POINTER (arity)))) {
mono_jit_unlock ();
return res;
}
MonoJitDynamicMethodInfo *res;
if (domain_jit_info (domain)->dynamic_code_hash)
- res = g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method);
+ res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method);
else
res = NULL;
return res;
LSCAN_DEBUG (printf ("Allocate Stack Slots 2 for %s:\n", mono_method_full_name (cfg->method, TRUE)));
- scalar_stack_slots = mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * MONO_TYPE_PINNED);
+ scalar_stack_slots = (StackSlotInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * MONO_TYPE_PINNED);
vtype_stack_slots = NULL;
nvtypes = 0;
- offsets = mono_mempool_alloc (cfg->mempool, sizeof (gint32) * cfg->num_varinfo);
+ offsets = (gint32 *)mono_mempool_alloc (cfg->mempool, sizeof (gint32) * cfg->num_varinfo);
for (i = 0; i < cfg->num_varinfo; ++i)
offsets [i] = -1;
offset = 0;
*stack_align = 0;
for (unhandled = vars; unhandled; unhandled = unhandled->next) {
- MonoMethodVar *current = unhandled->data;
+ MonoMethodVar *current = (MonoMethodVar *)unhandled->data;
vmv = current;
inst = cfg->varinfo [vmv->idx];
/* Fall through */
case MONO_TYPE_VALUETYPE:
if (!vtype_stack_slots)
- vtype_stack_slots = mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * 256);
+ vtype_stack_slots = (StackSlotInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * 256);
for (i = 0; i < nvtypes; ++i)
if (t->data.klass == vtype_stack_slots [i].vtype)
break;
if ((cfg->num_varinfo > 0) && MONO_VARINFO (cfg, 0)->interval)
return mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
- scalar_stack_slots = mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * MONO_TYPE_PINNED);
+ scalar_stack_slots = (StackSlotInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * MONO_TYPE_PINNED);
vtype_stack_slots = NULL;
nvtypes = 0;
- offsets = mono_mempool_alloc (cfg->mempool, sizeof (gint32) * cfg->num_varinfo);
+ offsets = (gint32 *)mono_mempool_alloc (cfg->mempool, sizeof (gint32) * cfg->num_varinfo);
for (i = 0; i < cfg->num_varinfo; ++i)
offsets [i] = -1;
offset = 0;
*stack_align = sizeof(mgreg_t);
for (l = vars; l; l = l->next) {
- vmv = l->data;
+ vmv = (MonoMethodVar *)l->data;
inst = cfg->varinfo [vmv->idx];
t = mono_type_get_underlying_type (inst->inst_vtype);
/* Fall through */
case MONO_TYPE_VALUETYPE:
if (!vtype_stack_slots)
- vtype_stack_slots = mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * 256);
+ vtype_stack_slots = (StackSlotInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (StackSlotInfo) * 256);
for (i = 0; i < nvtypes; ++i)
if (t->data.klass == vtype_stack_slots [i].vtype)
break;
if (emul_opcode_num >= emul_opcode_alloced) {
int incr = emul_opcode_alloced? emul_opcode_alloced/2: 16;
emul_opcode_alloced += incr;
- emul_opcode_map = g_realloc (emul_opcode_map, sizeof (emul_opcode_map [0]) * emul_opcode_alloced);
- emul_opcode_opcodes = g_realloc (emul_opcode_opcodes, sizeof (emul_opcode_opcodes [0]) * emul_opcode_alloced);
+ emul_opcode_map = (MonoJitICallInfo **)g_realloc (emul_opcode_map, sizeof (emul_opcode_map [0]) * emul_opcode_alloced);
+ emul_opcode_opcodes = (short *)g_realloc (emul_opcode_opcodes, sizeof (emul_opcode_opcodes [0]) * emul_opcode_alloced);
}
emul_opcode_map [emul_opcode_num] = info;
emul_opcode_opcodes [emul_opcode_num] = opcode;
if (cfg->exvars)
g_hash_table_destroy (cfg->exvars);
for (l = cfg->headers_to_free; l; l = l->next)
- mono_metadata_free_mh (l->data);
+ mono_metadata_free_mh ((MonoMethodHeader *)l->data);
g_list_free (cfg->ldstr_list);
g_hash_table_destroy (cfg->token_info_hash);
if (cfg->abs_patches)
void
mono_add_patch_info (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target)
{
- MonoJumpInfo *ji = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfo));
+ MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfo));
ji->ip.i = ip;
ji->type = type;
void
mono_add_patch_info_rel (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target, int relocation)
{
- MonoJumpInfo *ji = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfo));
+ MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfo));
ji->ip.i = ip;
ji->type = type;
void
mono_add_var_location (MonoCompile *cfg, MonoInst *var, gboolean is_reg, int reg, int offset, int from, int to)
{
- MonoDwarfLocListEntry *entry = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDwarfLocListEntry));
+ MonoDwarfLocListEntry *entry = (MonoDwarfLocListEntry *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDwarfLocListEntry));
if (is_reg)
g_assert (offset == 0);
if (cfg->verbose_level > 2)
g_print ("creating vars\n");
- cfg->args = mono_mempool_alloc0 (cfg->mempool, (sig->param_count + sig->hasthis) * sizeof (MonoInst*));
+ cfg->args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, (sig->param_count + sig->hasthis) * sizeof (MonoInst*));
if (sig->hasthis)
cfg->args [0] = mono_compile_create_var (cfg, &cfg->method->klass->this_arg, OP_ARG);
}
cfg->locals_start = cfg->num_varinfo;
- cfg->locals = mono_mempool_alloc0 (cfg->mempool, header->num_locals * sizeof (MonoInst*));
+ cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, header->num_locals * sizeof (MonoInst*));
if (cfg->verbose_level > 2)
g_print ("creating locals\n");
if (patch_info->type == MONO_PATCH_INFO_ABS) {
if (cfg->abs_patches) {
- MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, patch_info->data.target);
+ MonoJumpInfo *abs_ji = (MonoJumpInfo *)g_hash_table_lookup (cfg->abs_patches, patch_info->data.target);
if (abs_ji) {
patch_info->type = abs_ji->type;
patch_info->data.target = abs_ji->data.target;
table = g_malloc0 (sizeof(gpointer) * patch_info->data.table->table_size);
#else
if (cfg->method->dynamic) {
- table = mono_code_manager_reserve (cfg->dynamic_info->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
+ table = (void **)mono_code_manager_reserve (cfg->dynamic_info->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
} else {
- table = mono_domain_code_reserve (cfg->domain, sizeof (gpointer) * patch_info->data.table->table_size);
+ table = (void **)mono_domain_code_reserve (cfg->domain, sizeof (gpointer) * patch_info->data.table->table_size);
}
#endif
#endif
mono_domain_lock (domain);
- jlist = g_hash_table_lookup (domain_jit_info (domain)->jump_target_hash, patch_info->data.method);
+ jlist = (MonoJumpList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_hash, patch_info->data.method);
if (!jlist) {
- jlist = mono_domain_alloc0 (domain, sizeof (MonoJumpList));
+ jlist = (MonoJumpList *)mono_domain_alloc0 (domain, sizeof (MonoJumpList));
g_hash_table_insert (domain_jit_info (domain)->jump_target_hash, patch_info->data.method, jlist);
}
jlist->list = g_slist_prepend (jlist->list, ip);
if (mono_using_xdebug)
/* See the comment for cfg->code_domain */
- code = mono_domain_code_reserve (code_domain, cfg->code_size + cfg->thunk_area + unwindlen);
+ code = (guint8 *)mono_domain_code_reserve (code_domain, cfg->code_size + cfg->thunk_area + unwindlen);
else
- code = mono_code_manager_reserve (cfg->dynamic_info->code_mp, cfg->code_size + cfg->thunk_area + unwindlen);
+ code = (guint8 *)mono_code_manager_reserve (cfg->dynamic_info->code_mp, cfg->code_size + cfg->thunk_area + unwindlen);
} else {
- code = mono_domain_code_reserve (code_domain, cfg->code_size + cfg->thunk_area + unwindlen);
+ code = (guint8 *)mono_domain_code_reserve (code_domain, cfg->code_size + cfg->thunk_area + unwindlen);
}
#if defined(__native_client_codegen__) && defined(__native_client__)
nacl_allow_target_modification (TRUE);
header = cfg->header;
if (cfg->gshared)
- flags |= JIT_INFO_HAS_GENERIC_JIT_INFO;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_GENERIC_JIT_INFO);
if (cfg->arch_eh_jit_info) {
MonoJitArgumentInfo *arg_info;
stack_size = mono_arch_get_argument_info (sig, sig->param_count, arg_info);
if (stack_size)
- flags |= JIT_INFO_HAS_ARCH_EH_INFO;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_ARCH_EH_INFO);
}
if (cfg->has_unwind_info_for_epilog && !(flags & JIT_INFO_HAS_ARCH_EH_INFO))
- flags |= JIT_INFO_HAS_ARCH_EH_INFO;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_ARCH_EH_INFO);
if (cfg->thunk_area)
- flags |= JIT_INFO_HAS_THUNK_INFO;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_THUNK_INFO);
if (cfg->try_block_holes) {
for (tmp = cfg->try_block_holes; tmp; tmp = tmp->next) {
- TryBlockHole *hole = tmp->data;
+ TryBlockHole *hole = (TryBlockHole *)tmp->data;
MonoExceptionClause *ec = hole->clause;
int hole_end = hole->basic_block->native_offset + hole->basic_block->native_length;
MonoBasicBlock *clause_last_bb = cfg->cil_offset_to_bb [ec->try_offset + ec->try_len];
++num_holes;
}
if (num_holes)
- flags |= JIT_INFO_HAS_TRY_BLOCK_HOLES;
+ flags = (MonoJitInfoFlags)(flags | JIT_INFO_HAS_TRY_BLOCK_HOLES);
if (G_UNLIKELY (cfg->verbose_level >= 4))
printf ("Number of try block holes %d\n", num_holes);
}
num_clauses = header->num_clauses;
if (cfg->method->dynamic)
- jinfo = g_malloc0 (mono_jit_info_size (flags, num_clauses, num_holes));
+ jinfo = (MonoJitInfo *)g_malloc0 (mono_jit_info_size (flags, num_clauses, num_holes));
else
- jinfo = mono_domain_alloc0 (cfg->domain, mono_jit_info_size (flags, num_clauses, num_holes));
+ jinfo = (MonoJitInfo *)mono_domain_alloc0 (cfg->domain, mono_jit_info_size (flags, num_clauses, num_holes));
mono_jit_info_init (jinfo, cfg->method_to_register, cfg->native_code, cfg->code_len, flags, num_clauses, num_holes);
jinfo->domain_neutral = (cfg->opt & MONO_OPT_SHARED) != 0;
if (cfg->method->dynamic)
gi->generic_sharing_context = g_new0 (MonoGenericSharingContext, 1);
else
- gi->generic_sharing_context = mono_domain_alloc0 (cfg->domain, sizeof (MonoGenericSharingContext));
+ gi->generic_sharing_context = (MonoGenericSharingContext *)mono_domain_alloc0 (cfg->domain, sizeof (MonoGenericSharingContext));
mini_init_gsctx (cfg->method->dynamic ? NULL : cfg->domain, NULL, cfg->gsctx_context, gi->generic_sharing_context);
if ((method_to_compile->flags & METHOD_ATTRIBUTE_STATIC) ||
gi->nlocs = g_slist_length (loclist);
if (cfg->method->dynamic)
- gi->locations = g_malloc0 (gi->nlocs * sizeof (MonoDwarfLocListEntry));
+ gi->locations = (MonoDwarfLocListEntry *)g_malloc0 (gi->nlocs * sizeof (MonoDwarfLocListEntry));
else
- gi->locations = mono_domain_alloc0 (cfg->domain, gi->nlocs * sizeof (MonoDwarfLocListEntry));
+ gi->locations = (MonoDwarfLocListEntry *)mono_domain_alloc0 (cfg->domain, gi->nlocs * sizeof (MonoDwarfLocListEntry));
i = 0;
for (l = loclist; l; l = l->next) {
memcpy (&(gi->locations [i]), l->data, sizeof (MonoDwarfLocListEntry));
for (tmp = cfg->try_block_holes; tmp; tmp = tmp->next) {
guint32 start_bb_offset;
MonoTryBlockHoleJitInfo *hole;
- TryBlockHole *hole_data = tmp->data;
+ TryBlockHole *hole_data = (TryBlockHole *)tmp->data;
MonoExceptionClause *ec = hole_data->clause;
int hole_end = hole_data->basic_block->native_offset + hole_data->basic_block->native_length;
MonoBasicBlock *clause_last_bb = cfg->cil_offset_to_bb [ec->try_offset + ec->try_len];
ei->handler_start = cfg->native_code + tblock->native_offset;
for (tmp = cfg->try_block_holes; tmp; tmp = tmp->next) {
- TryBlockHole *hole = tmp->data;
+ TryBlockHole *hole = (TryBlockHole *)tmp->data;
gpointer hole_end = cfg->native_code + (hole->basic_block->native_offset + hole->basic_block->native_length);
if (hole->clause == ec && hole_end == ei->try_end) {
if (G_UNLIKELY (cfg->verbose_level >= 4))
}
}
- cfg->intvars = mono_mempool_alloc0 (cfg->mempool, sizeof (guint16) * STACK_MAX * header->max_stack);
+ cfg->intvars = (guint16 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint16) * STACK_MAX * header->max_stack);
if (cfg->verbose_level > 0) {
char *method_name;
mono_threads_safepoint ();
/* Depth-first ordering on basic blocks */
- cfg->bblocks = mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * (cfg->num_bblocks + 1));
+ cfg->bblocks = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * (cfg->num_bblocks + 1));
cfg->max_block_num = cfg->num_bblocks;
bb->last_ins->opcode = mono_reverse_branch_op (bb->last_ins->opcode);
} else {
- MonoInst *inst = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
+ MonoInst *inst = (MonoInst *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
inst->opcode = OP_BR;
inst->inst_target_bb = bb->last_ins->inst_false_bb;
mono_bblock_add_inst (bb, inst);
void
mono_cfg_add_try_hole (MonoCompile *cfg, MonoExceptionClause *clause, guint8 *start, MonoBasicBlock *bb)
{
- TryBlockHole *hole = mono_mempool_alloc (cfg->mempool, sizeof (TryBlockHole));
+ TryBlockHole *hole = (TryBlockHole *)mono_mempool_alloc (cfg->mempool, sizeof (TryBlockHole));
hole->clause = clause;
hole->start_offset = start - cfg->native_code;
hole->basic_block = bb;
uw_info = mono_unwind_ops_encode (info->unwind_ops, &info_len);
}
- jinfo = mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO);
+ jinfo = (MonoJitInfo *)mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO);
jinfo->d.method = wrapper;
jinfo->code_start = info->code;
jinfo->code_size = info->code_size;
}
nm = mono_marshal_get_native_wrapper (method, TRUE, mono_aot_only);
code = mono_get_addr_from_ftnptr (mono_compile_method (nm));
- jinfo = mono_jit_info_table_find (target_domain, code);
+ jinfo = mono_jit_info_table_find (target_domain, (char *)code);
if (!jinfo)
- jinfo = mono_jit_info_table_find (mono_domain_get (), code);
+ jinfo = mono_jit_info_table_find (mono_domain_get (), (char *)code);
if (jinfo)
mono_profiler_method_end_jit (method, jinfo, MONO_PROFILE_OK);
return code;
ex = mono_loader_error_prepare_exception (error);
} else {
if (cfg->exception_ptr) {
- ex = mono_class_get_exception_for_failure (cfg->exception_ptr);
+ ex = mono_class_get_exception_for_failure ((MonoClass *)cfg->exception_ptr);
} else {
if (cfg->exception_type == MONO_EXCEPTION_MISSING_FIELD)
ex = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingFieldException", cfg->exception_message);
ex = mono_exception_from_name_msg (mono_defaults.corlib, "System", "FieldAccessException", cfg->exception_message);
break;
case MONO_EXCEPTION_OBJECT_SUPPLIED: {
- MonoException *exp = cfg->exception_ptr;
+ MonoException *exp = (MonoException *)cfg->exception_ptr;
MONO_GC_UNREGISTER_ROOT (cfg->exception_ptr);
ex = exp;
MonoJumpInfo patch_info;
MonoJumpList *jlist;
GSList *tmp;
- jlist = g_hash_table_lookup (domain_jit_info (target_domain)->jump_target_hash, method);
+ jlist = (MonoJumpList *)g_hash_table_lookup (domain_jit_info (target_domain)->jump_target_hash, method);
if (jlist) {
patch_info.next = NULL;
patch_info.ip.i = 0;
#endif
#ifdef MONO_ARCH_HAVE_PATCH_CODE_NEW
for (tmp = jlist->list; tmp; tmp = tmp->next) {
- gpointer target = mono_resolve_patch_target (NULL, target_domain, tmp->data, &patch_info, TRUE);
- mono_arch_patch_code_new (NULL, target_domain, tmp->data, &patch_info, target);
+ gpointer target = mono_resolve_patch_target (NULL, target_domain, (guint8 *)tmp->data, &patch_info, TRUE);
+ mono_arch_patch_code_new (NULL, target_domain, (guint8 *)tmp->data, &patch_info, target);
}
#else
for (tmp = jlist->list; tmp; tmp = tmp->next)
} while (0)
#define MONO_INST_NEW(cfg,dest,op) do { \
- (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
+ (dest) = (MonoInst *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->opcode = (op); \
(dest)->dreg = -1; \
MONO_INST_NULLIFY_SREGS ((dest)); \
} while (0)
#define MONO_INST_NEW_CALL(cfg,dest,op) do { \
- (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); \
+ (dest) = (MonoCallInst *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); \
(dest)->inst.opcode = (op); \
(dest)->inst.dreg = -1; \
MONO_INST_NULLIFY_SREGS (&(dest)->inst); \
GSList* mono_arch_get_delegate_invoke_impls (void);
LLVMCallInfo* mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) MONO_LLVM_INTERNAL;
guint8* mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji);
-guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target);
+guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, MonoJumpInfoType tramp_type, gconstpointer target);
GSList* mono_arch_get_cie_program (void);
void mono_arch_set_target (char *mtriple);
gboolean mono_arch_gsharedvt_sig_supported (MonoMethodSignature *sig);
typedef gboolean (*MonoJitStackWalk) (StackFrameInfo *frame, MonoContext *ctx, gpointer data);
void mono_exceptions_init (void);
-gboolean mono_handle_exception (MonoContext *ctx, gpointer obj);
+gboolean mono_handle_exception (MonoContext *ctx, MonoObject *obj);
void mono_handle_native_sigsegv (int signal, void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo);
MONO_API void mono_print_thread_dump (void *sigctx);
MONO_API void mono_print_thread_dump_from_ctx (MonoContext *ctx);
for (i = 0; i < cfg->seq_points->len; ++i) {
SeqPoint *sp = &seq_points [i];
- MonoInst *ins = g_ptr_array_index (cfg->seq_points, i);
+ MonoInst *ins = (MonoInst *)g_ptr_array_index (cfg->seq_points, i);
sp->il_offset = ins->inst_imm;
sp->native_offset = ins->inst_offset;
bb_seq_points = g_slist_reverse (bb->seq_points);
last = NULL;
for (l = bb_seq_points; l; l = l->next) {
- MonoInst *ins = l->data;
+ MonoInst *ins = (MonoInst *)l->data;
if (ins->inst_imm == METHOD_ENTRY_IL_OFFSET || ins->inst_imm == METHOD_EXIT_IL_OFFSET)
/* Used to implement method entry/exit events */
*/
l = g_slist_last (bb->seq_points);
if (l) {
- endfinally_seq_point = l->data;
+ endfinally_seq_point = (MonoInst *)l->data;
for (bb2 = cfg->bb_entry; bb2; bb2 = bb2->next_bb) {
GSList *l = g_slist_last (bb2->seq_points);
if (l) {
- MonoInst *ins = l->data;
+ MonoInst *ins = (MonoInst *)l->data;
if (!(ins->inst_imm == METHOD_ENTRY_IL_OFFSET || ins->inst_imm == METHOD_EXIT_IL_OFFSET) && ins != endfinally_seq_point)
next [endfinally_seq_point->backend.size] = g_slist_append (next [endfinally_seq_point->backend.size], GUINT_TO_POINTER (ins->backend.size));
}
mono_loader_lock ();
- seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
if (!seq_points && method->is_inflated) {
/* generic sharing + aot */
- seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring_generic_method);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring_generic_method);
if (!seq_points)
- seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, shared_method);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, shared_method);
}
mono_loader_unlock ();
mono_image_get_aot_seq_point_path (MonoImage *image, char **str)
{
int size = strlen (image->name) + strlen (SEQ_POINT_AOT_EXT) + 1;
- *str = g_malloc (size);
+ *str = (char *)g_malloc (size);
g_sprintf (*str, "%s%s", image->name, SEQ_POINT_AOT_EXT);
}
}
DEBUG (printf ("[simd-simplify] max vreg is %d\n", max_vreg));
- vreg_flags = g_malloc0 (max_vreg + 1);
+ vreg_flags = (char *)g_malloc0 (max_vreg + 1);
target_bb = g_new0 (MonoBasicBlock*, max_vreg + 1);
for (i = 0; i < cfg->num_varinfo; i++) {
static MonoInst*
emit_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args, const SimdIntrinsc *intrinsics, guint32 size)
{
- const SimdIntrinsc * result = mono_binary_search (cmethod->name, intrinsics, size, sizeof (SimdIntrinsc), &simd_intrinsic_compare_by_name);
+ const SimdIntrinsc *result = (const SimdIntrinsc *)mono_binary_search (cmethod->name, intrinsics, size, sizeof (SimdIntrinsc), &simd_intrinsic_compare_by_name);
if (!result) {
DEBUG (printf ("function doesn't have a simd intrinsic %s::%s/%d\n", cmethod->klass->name, cmethod->name, fsig->param_count));
return NULL;
record_use (MonoCompile *cfg, MonoInst *var, MonoBasicBlock *bb, MonoInst *ins)
{
MonoMethodVar *info;
- MonoVarUsageInfo *ui = mono_mempool_alloc (cfg->mempool, sizeof (MonoVarUsageInfo));
+ MonoVarUsageInfo *ui = (MonoVarUsageInfo *)mono_mempool_alloc (cfg->mempool, sizeof (MonoVarUsageInfo));
info = MONO_VARINFO (cfg, var->inst_c0);
mono_compile_dominator_info (cfg, MONO_COMP_DOM | MONO_COMP_IDOM | MONO_COMP_DFRONTIER);
bitsize = mono_bitset_alloc_size (cfg->num_bblocks, 0);
- buf = buf_start = g_malloc0 (mono_bitset_alloc_size (cfg->num_bblocks, 0) * cfg->num_varinfo);
+ buf = buf_start = (guint8 *)g_malloc0 (mono_bitset_alloc_size (cfg->num_bblocks, 0) * cfg->num_varinfo);
for (i = 0; i < cfg->num_varinfo; ++i) {
vinfo [i].def_in = mono_bitset_mem_new (buf, cfg->num_bblocks, 0);
else
ins->klass = var->klass;
- ins->inst_phi_args = mono_mempool_alloc0 (cfg->mempool, sizeof (int) * (cfg->bblocks [idx]->in_count + 1));
+ ins->inst_phi_args = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * (cfg->bblocks [idx]->in_count + 1));
ins->inst_phi_args [0] = cfg->bblocks [idx]->in_count;
/* For debugging */
/* Renaming phase */
- stack = alloca (sizeof (MonoInst *) * cfg->num_varinfo);
+ stack = (MonoInst **)alloca (sizeof (MonoInst *) * cfg->num_varinfo);
memset (stack, 0, sizeof (MonoInst *) * cfg->num_varinfo);
lvreg_stack = g_new0 (guint32, cfg->next_vreg);
if (MONO_IS_JUMP_TABLE (ins)) {
int i;
- MonoJumpInfoBBTable *table = MONO_JUMP_TABLE_FROM_INS (ins);
+ MonoJumpInfoBBTable *table = (MonoJumpInfoBBTable *)MONO_JUMP_TABLE_FROM_INS (ins);
if (!ins->next || ins->next->opcode != OP_PADD) {
/* The PADD was optimized away */
if (ins->opcode == OP_SWITCH) {
int i;
- MonoJumpInfoBBTable *table = ins->inst_p0;
+ MonoJumpInfoBBTable *table = (MonoJumpInfoBBTable *)ins->inst_p0;
for (i = 0; i < table->table_size; i++)
if (table->table [i])
if (MONO_IS_JUMP_TABLE (ins)) {
int i;
- MonoJumpInfoBBTable *table = MONO_JUMP_TABLE_FROM_INS (ins);
+ MonoJumpInfoBBTable *table = (MonoJumpInfoBBTable *)MONO_JUMP_TABLE_FROM_INS (ins);
if (!ins->next || ins->next->opcode != OP_PADD) {
/* The PADD was optimized away */
if (cont->domain)
return mono_get_exception_argument ("cont", "Already marked");
- jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
lmf = mono_get_lmf();
cont->domain = mono_domain_get ();
cont->thread_id = mono_native_thread_id_get ();
}
if (value != NULL)
g_free (value);
- value = g_malloc (input - start + 1);
+ value = (char *)g_malloc (input - start + 1);
strncpy (value, start, input-start);
value [input-start] = 0;
}
sig = mono_method_signature (method);
- arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1));
+ arg_info = (MonoJitArgumentInfo *)alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1));
if (method->is_inflated) {
/* FIXME: Might be better to pass the ji itself */
- MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), RETURN_ADDRESS (), NULL);
+ MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (char *)RETURN_ADDRESS (), NULL);
if (ji) {
gsctx = mono_jit_info_get_generic_sharing_context (ji);
if (gsctx && gsctx->is_gsharedvt) {
}
if (mono_method_signature (method)->hasthis) {
- gpointer *this = (gpointer *)(ebp + arg_info [0].offset);
+ gpointer *this_obj = (gpointer *)(ebp + arg_info [0].offset);
if (method->klass->valuetype) {
- printf ("value:%p, ", *arg_in_stack_slot(this, gpointer *));
+ printf ("value:%p, ", *arg_in_stack_slot(this_obj, gpointer *));
} else {
- o = *arg_in_stack_slot(this, MonoObject *);
+ o = *arg_in_stack_slot(this_obj, MonoObject *);
if (o) {
klass = o->vtable->klass;
if (method->is_inflated) {
/* FIXME: Might be better to pass the ji itself */
- MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), RETURN_ADDRESS (), NULL);
+ MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (char *)RETURN_ADDRESS (), NULL);
if (ji) {
gsctx = mono_jit_info_get_generic_sharing_context (ji);
if (gsctx && gsctx->is_gsharedvt) {
break;
}
case MONO_TYPE_VALUETYPE: {
- guint8 *p = va_arg (ap, gpointer);
+ guint8 *p = (guint8 *)va_arg (ap, gpointer);
int j, size, align;
size = mono_type_size (type, &align);
printf ("[");
this_reg = mono_arch_get_this_arg_reg (NULL);
- start = code = mono_domain_code_reserve (domain, size);
+ start = code = (guint8 *)mono_domain_code_reserve (domain, size);
unwind_ops = mono_arch_get_cie_program ();
buf_len = NACL_SIZE (30, 32);
#endif
- start = code = mono_domain_code_reserve (domain, buf_len);
+ start = code = (guint8 *)mono_domain_code_reserve (domain, buf_len);
unwind_ops = mono_arch_get_cie_program ();
*/
guint8 *thunk_start, *thunk_code;
- thunk_start = thunk_code = mono_domain_code_reserve (mono_domain_get (), 32);
+ thunk_start = thunk_code = (guint8 *)mono_domain_code_reserve (mono_domain_get (), 32);
amd64_jump_membase (thunk_code, AMD64_RIP, 0);
*(guint64*)thunk_code = (guint64)addr;
addr = thunk_start;
*/
guint8 *thunk_start, *thunk_code;
- thunk_start = thunk_code = mono_domain_code_reserve (mono_domain_get (), 32);
+ thunk_start = thunk_code = (guint8 *)mono_domain_code_reserve (mono_domain_get (), 32);
amd64_jump_membase (thunk_code, AMD64_RIP, 0);
*(guint64*)thunk_code = (guint64)addr;
addr = thunk_start;
else
has_caller = TRUE;
- code = buf = mono_global_codeman_reserve (kMaxCodeSize);
+ code = buf = (guint8 *)mono_global_codeman_reserve (kMaxCodeSize);
/* Compute stack frame size and offsets */
offset = 0;
else
size = 5 + 1 + 8;
- code = buf = mono_domain_code_reserve_align (domain, size, 1);
+ code = buf = (guint8 *)mono_domain_code_reserve_align (domain, size, 1);
if (((gint64)tramp - (gint64)code) >> 31 != 0 && ((gint64)tramp - (gint64)code) >> 31 != -1) {
#ifndef MONO_ARCH_NOMAP32BIT
#endif
far_addr = TRUE;
size += 16;
- code = buf = mono_domain_code_reserve_align (domain, size, 1);
+ code = buf = (guint8 *)mono_domain_code_reserve_align (domain, size, 1);
}
#elif defined(__native_client_codegen__)
size = 5 + 1 + 4;
tramp_size = NACL_SIZE (64 + 8 * depth, 128 + 8 * depth);
- code = buf = mono_global_codeman_reserve (tramp_size);
+ code = buf = (guint8 *)mono_global_codeman_reserve (tramp_size);
unwind_ops = mono_arch_get_cie_program ();
- rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
+ rgctx_null_jumps = (guint8 **)g_malloc (sizeof (guint8*) * (depth + 2));
if (mrgctx) {
/* get mrgctx ptr */
code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
amd64_jump_reg (code, AMD64_R11);
} else {
- tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
+ tramp = (guint8 *)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
/* jump to the actual trampoline */
amd64_jump_code (code, tramp);
mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg)
{
/* FIXME: This is not thread safe */
- guint8 *code = ji->code_start;
+ guint8 *code = (guint8 *)ji->code_start;
amd64_mov_reg_imm (code, AMD64_ARG_REG1, func_arg);
amd64_mov_reg_imm (code, AMD64_R11, func);
static void
handler_block_trampoline_helper (gpointer *ptr)
{
- MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
*ptr = jit_tls->handler_block_return_address;
}
g_assert (!aot);
- code = buf = mono_global_codeman_reserve (tramp_size);
+ code = buf = (guint8 *)mono_global_codeman_reserve (tramp_size);
unwind_ops = mono_arch_get_cie_program ();
GSList *unwind_ops = NULL;
MonoJumpInfo *ji = NULL;
- code = buf = mono_global_codeman_reserve (tramp_size);
+ code = buf = (guint8 *)mono_global_codeman_reserve (tramp_size);
framesize = 0;
#ifdef TARGET_WIN32
/* Argument area */
framesize += sizeof (mgreg_t);
+ framesize = ALIGN_TO (framesize, 8);
ctx_offset = framesize;
framesize += sizeof (MonoContext);
for (; l; l = l->next) {
int reg;
- op = l->data;
+ op = (MonoUnwindOp *)l->data;
/* Convert the register from the hw encoding to the dwarf encoding */
reg = mono_hw_reg_to_dwarf_reg (op->reg);
g_assert (p - buf < 4096);
*out_len = p - buf;
- res = g_malloc (p - buf);
+ res = (guint8 *)g_malloc (p - buf);
memcpy (res, buf, p - buf);
return res;
}
}
}
- info = g_malloc (sizeof (MonoUnwindInfo) + unwind_info_len);
+ info = (MonoUnwindInfo *)g_malloc (sizeof (MonoUnwindInfo) + unwind_info_len);
info->len = unwind_info_len;
memcpy (&info->info, unwind_info, unwind_info_len);
p = (guint8*)ALIGN_TO ((mgreg_t)p, 4);
if (ex_info) {
- *ex_info = g_malloc0 (ncall_sites * sizeof (MonoJitExceptionInfo));
+ *ex_info = (MonoJitExceptionInfo *)g_malloc0 (ncall_sites * sizeof (MonoJitExceptionInfo));
*ex_info_len = ncall_sites;
}
if (type_info)
- *type_info = g_malloc0 (ncall_sites * sizeof (gpointer));
+ *type_info = (gpointer *)g_malloc0 (ncall_sites * sizeof (gpointer));
for (i = 0; i < ncall_sites; ++i) {
int block_start_offset, block_size, landing_pad;
g_assert (return_reg == DWARF_PC_REG);
buf_len = (cie + cie_len + 4 - cie_cfi) + (fde + fde_len + 4 - fde_cfi);
- buf = g_malloc0 (buf_len);
+ buf = (guint8 *)g_malloc0 (buf_len);
i = 0;
p = cie_cfi;
*out_len = i;
- return g_realloc (buf, i);
+ return (guint8 *)g_realloc (buf, i);
}
/*
cie_cfi_len = p - cie_cfi;
fde_cfi_len = (fde + fde_len - fde_cfi);
- buf = g_malloc0 (cie_cfi_len + fde_cfi_len);
+ buf = (guint8 *)g_malloc0 (cie_cfi_len + fde_cfi_len);
memcpy (buf, cie_cfi, cie_cfi_len);
memcpy (buf + cie_cfi_len, fde_cfi, fde_cfi_len);
pstrdup (const char *s)
{
int len = strlen (s) + 1;
- char *p = malloc (len);
+ char *p = (char *)malloc (len);
memcpy (p, s, len);
return p;
}
CounterSection *csection, *s;
CounterList *clist;
- clist = calloc (1, sizeof (CounterList));
+ clist = (CounterList *)calloc (1, sizeof (CounterList));
clist->counter = counter;
for (csection = counters_sections; csection; csection = csection->next) {
}
/* If section does not exist */
- csection = calloc (1, sizeof (CounterSection));
+ csection = (CounterSection *)calloc (1, sizeof (CounterSection));
csection->value = counter->section;
csection->counters = clist;
csection->counters_last = clist;
if (list->counter->index == index)
return;
- counter = calloc (1, sizeof (Counter));
+ counter = (Counter *)calloc (1, sizeof (Counter));
counter->section = section;
counter->name = name;
counter->type = type;
counter->variance = variance;
counter->index = index;
- list = calloc (1, sizeof (CounterList));
+ list = (CounterList *)calloc (1, sizeof (CounterList));
list->counter = counter;
if (!counters) {
CounterSection *csection;
CounterList *clist;
- clist = calloc (1, sizeof (CounterList));
+ clist = (CounterList *)calloc (1, sizeof (CounterList));
clist->counter = counter;
for (ctimestamp = counters_timestamps; ctimestamp; ctimestamp = ctimestamp->next) {
}
/* if timestamp exist and section does not exist */
- csection = calloc (1, sizeof (CounterSection));
+ csection = (CounterSection *)calloc (1, sizeof (CounterSection));
csection->value = counter->section;
csection->counters = clist;
csection->counters_last = clist;
}
/* If timestamp do not exist and section does not exist */
- csection = calloc (1, sizeof (CounterSection));
+ csection = (CounterSection *)calloc (1, sizeof (CounterSection));
csection->value = counter->section;
csection->counters = clist;
csection->counters_last = clist;
- ctimestamp = calloc (1, sizeof (CounterTimestamp));
+ ctimestamp = (CounterTimestamp *)calloc (1, sizeof (CounterTimestamp));
ctimestamp->value = timestamp;
ctimestamp->sections = csection;
ctimestamp->sections_last = csection;
add_image (intptr_t image, char *name)
{
int slot = ((image >> 2) & 0xffff) % SMALL_HASH_SIZE;
- ImageDesc *cd = malloc (sizeof (ImageDesc));
+ ImageDesc *cd = (ImageDesc *)malloc (sizeof (ImageDesc));
cd->image = image;
cd->filename = pstrdup (name);
cd->next = image_hash [slot];
add_assembly (intptr_t assembly, char *name)
{
int slot = ((assembly >> 2) & 0xffff) % SMALL_HASH_SIZE;
- AssemblyDesc *cd = malloc (sizeof (AssemblyDesc));
+ AssemblyDesc *cd = (AssemblyDesc *)malloc (sizeof (AssemblyDesc));
cd->assembly = assembly;
cd->asmname = pstrdup (name);
cd->next = assembly_hash [slot];
cd->name = pstrdup (name);
return cd;
}
- cd = calloc (sizeof (ClassDesc), 1);
+ cd = (ClassDesc *)calloc (sizeof (ClassDesc), 1);
cd->klass = klass;
cd->name = pstrdup (name);
cd->next = class_hash [slot];
cd->name = pstrdup (name);
return cd;
}
- cd = calloc (sizeof (MethodDesc), 1);
+ cd = (MethodDesc *)calloc (sizeof (MethodDesc), 1);
cd->method = method;
cd->name = pstrdup (name);
cd->code = code;
size_stat_samples *= 2;
if (!size_stat_samples)
size_stat_samples = 32;
- stat_samples = realloc (stat_samples, size_stat_samples * sizeof (uintptr_t));
- stat_sample_desc = realloc (stat_sample_desc, size_stat_samples * sizeof (int));
+ stat_samples = (uintptr_t *)realloc (stat_samples, size_stat_samples * sizeof (uintptr_t));
+ stat_sample_desc = (int *)realloc (stat_sample_desc, size_stat_samples * sizeof (int));
}
stat_samples [num_stat_samples] = ip;
stat_sample_desc [num_stat_samples++] = type;
static int
compare_method_samples (const void *a, const void *b)
{
- MethodDesc *const*A = a;
- MethodDesc *const*B = b;
+ MethodDesc *const *A = (MethodDesc *const *)a;
+ MethodDesc *const *B = (MethodDesc *const *)b;
if ((*A)->sample_hits == (*B)->sample_hits)
return 0;
if ((*B)->sample_hits < (*A)->sample_hits)
static int
compare_usymbol_addr (const void *a, const void *b)
{
- UnmanagedSymbol *const*A = a;
- UnmanagedSymbol *const*B = b;
+ UnmanagedSymbol *const *A = (UnmanagedSymbol *const *)a;
+ UnmanagedSymbol *const *B = (UnmanagedSymbol *const *)b;
if ((*B)->addr == (*A)->addr)
return 0;
if ((*B)->addr > (*A)->addr)
static int
compare_usymbol_samples (const void *a, const void *b)
{
- UnmanagedSymbol *const*A = a;
- UnmanagedSymbol *const*B = b;
+ UnmanagedSymbol *const *A = (UnmanagedSymbol *const *)a;
+ UnmanagedSymbol *const *B = (UnmanagedSymbol *const *)b;
if ((*B)->sample_hits == (*A)->sample_hits)
return 0;
if ((*B)->sample_hits < (*A)->sample_hits)
int new_size = usymbols_size * 2;
if (!new_size)
new_size = 16;
- usymbols = realloc (usymbols, sizeof (void*) * new_size);
+ usymbols = (UnmanagedSymbol **)realloc (usymbols, sizeof (void*) * new_size);
usymbols_size = new_size;
}
- sym = calloc (sizeof (UnmanagedSymbol), 1);
+ sym = (UnmanagedSymbol *)calloc (sizeof (UnmanagedSymbol), 1);
sym->addr = addr;
sym->name = name;
sym->size = size;
int new_size = ubinaries_size * 2;
if (!new_size)
new_size = 16;
- ubinaries = realloc (ubinaries, sizeof (void*) * new_size);
+ ubinaries = (UnmanagedSymbol **)realloc (ubinaries, sizeof (void*) * new_size);
ubinaries_size = new_size;
}
- sym = calloc (sizeof (UnmanagedSymbol), 1);
+ sym = (UnmanagedSymbol *)calloc (sizeof (UnmanagedSymbol), 1);
sym->addr = addr;
sym->name = name;
sym->size = size;
msize *= 2;
if (!msize)
msize = 4;
- cachedm = realloc (cachedm, sizeof (void*) * msize);
+ cachedm = (MethodDesc **)realloc (cachedm, sizeof (void*) * msize);
}
cachedm [count++] = m;
}
usize *= 2;
if (!usize)
usize = 4;
- cachedus = realloc (cachedus, sizeof (void*) * usize);
+ cachedus = (UnmanagedSymbol **)realloc (cachedus, sizeof (void*) * usize);
}
cachedus [ucount++] = usym;
}
to->rev_hash_size *= 2;
if (to->rev_hash_size == 0)
to->rev_hash_size = 4;
- n = calloc (sizeof (HeapClassRevRef) * to->rev_hash_size, 1);
+ n = (HeapClassRevRef *)calloc (sizeof (HeapClassRevRef) * to->rev_hash_size, 1);
for (i = 0; i < old_size; ++i) {
if (to->rev_hash [i].klass)
add_rev_class_hashed (n, to->rev_hash_size, to->rev_hash [i].klass, to->rev_hash [i].count);
static HeapShot*
new_heap_shot (uint64_t timestamp)
{
- HeapShot *hs = calloc (sizeof (HeapShot), 1);
+ HeapShot *hs = (HeapShot *)calloc (sizeof (HeapShot), 1);
hs->hash_size = 4;
- hs->class_hash = calloc (sizeof (void*), hs->hash_size);
+ hs->class_hash = (HeapClassDesc **)calloc (sizeof (void*), hs->hash_size);
hs->timestamp = timestamp;
num_heap_shots++;
hs->next = heap_shots;
hash [i] = *retv;
return 1;
}
- hash [i] = calloc (sizeof (HeapClassDesc), 1);
+ hash [i] = (HeapClassDesc *)calloc (sizeof (HeapClassDesc), 1);
hash [i]->klass = klass;
hash [i]->total_size += size;
hash [i]->count += count;
hs->hash_size *= 2;
if (hs->hash_size == 0)
hs->hash_size = 4;
- n = calloc (sizeof (void*) * hs->hash_size, 1);
+ n = (HeapClassDesc **)calloc (sizeof (void*) * hs->hash_size, 1);
for (i = 0; i < old_size; ++i) {
res = hs->class_hash [i];
if (hs->class_hash [i])
static HeapObjectDesc*
alloc_heap_obj (uintptr_t objaddr, HeapClassDesc *hklass, uintptr_t num_refs)
{
- HeapObjectDesc* ho = calloc (sizeof (HeapObjectDesc) + num_refs * sizeof (uintptr_t), 1);
+ HeapObjectDesc* ho = (HeapObjectDesc *)calloc (sizeof (HeapObjectDesc) + num_refs * sizeof (uintptr_t), 1);
ho->objaddr = objaddr;
ho->hklass = hklass;
ho->num_refs = num_refs;
hs->objects_hash_size *= 2;
if (hs->objects_hash_size == 0)
hs->objects_hash_size = 4;
- n = calloc (sizeof (void*) * hs->objects_hash_size, 1);
+ n = (HeapObjectDesc **)calloc (sizeof (void*) * hs->objects_hash_size, 1);
for (i = 0; i < old_size; ++i) {
if (hs->objects_hash [i])
add_heap_hashed_obj (n, hs->objects_hash_size, hs->objects_hash [i]);
if (!debug)
return;
/* consistency checks: it seems not all the objects are walked in the heap in some cases */
- marks = calloc (hs->objects_hash_size, 1);
+ marks = (unsigned char *)calloc (hs->objects_hash_size, 1);
if (!marks)
return;
for (i = 0; i < hs->num_roots; ++i) {
return bt;
bt = bt->next;
}
- bt = malloc (sizeof (BackTrace) + ((count - 1) * sizeof (void*)));
+ bt = (BackTrace *)malloc (sizeof (BackTrace) + ((count - 1) * sizeof (void*)));
bt->next = backtrace_hash [slot];
backtrace_hash [slot] = bt;
if (next_backtrace == num_backtraces) {
num_backtraces *= 2;
if (!num_backtraces)
num_backtraces = 16;
- backtraces = realloc (backtraces, sizeof (void*) * num_backtraces);
+ backtraces = (BackTrace **)realloc (backtraces, sizeof (void*) * num_backtraces);
}
bt->id = next_backtrace++;
backtraces [bt->id] = bt;
ensure_buffer (ProfContext *ctx, int size)
{
if (ctx->size < size) {
- ctx->buf = realloc (ctx->buf, size);
+ ctx->buf = (unsigned char *)realloc (ctx->buf, size);
ctx->size = size;
}
}
}
thread = thread->next;
}
- thread = calloc (sizeof (ThreadContext), 1);
+ thread = (ThreadContext *)calloc (sizeof (ThreadContext), 1);
thread->next = ctx->threads;
ctx->threads = thread;
thread->thread_id = thread_id;
thread->last_time = 0;
thread->stack_id = 0;
thread->stack_size = 32;
- thread->stack = malloc (thread->stack_size * sizeof (void*));
- thread->time_stack = malloc (thread->stack_size * sizeof (uint64_t));
- thread->callee_time_stack = malloc (thread->stack_size * sizeof (uint64_t));
+ thread->stack = (MethodDesc **)malloc (thread->stack_size * sizeof (void*));
+ thread->time_stack = (uint64_t *)malloc (thread->stack_size * sizeof (uint64_t));
+ thread->callee_time_stack = (uint64_t *)malloc (thread->stack_size * sizeof (uint64_t));
return thread;
}
domain = domain->next;
}
- domain = calloc (sizeof (DomainContext), 1);
+ domain = (DomainContext *)calloc (sizeof (DomainContext), 1);
domain->next = ctx->domains;
ctx->domains = domain;
domain->domain_id = domain_id;
remctx = remctx->next;
}
- remctx = calloc (sizeof (RemCtxContext), 1);
+ remctx = (RemCtxContext *)calloc (sizeof (RemCtxContext), 1);
remctx->next = ctx->remctxs;
ctx->remctxs = remctx;
remctx->remctx_id = remctx_id;
{
if (thread->stack_id == thread->stack_size) {
thread->stack_size *= 2;
- thread->stack = realloc (thread->stack, thread->stack_size * sizeof (void*));
- thread->time_stack = realloc (thread->time_stack, thread->stack_size * sizeof (uint64_t));
- thread->callee_time_stack = realloc (thread->callee_time_stack, thread->stack_size * sizeof (uint64_t));
+ thread->stack = (MethodDesc **)realloc (thread->stack, thread->stack_size * sizeof (void*));
+ thread->time_stack = (uint64_t *)realloc (thread->time_stack, thread->stack_size * sizeof (uint64_t));
+ thread->callee_time_stack = (uint64_t *)realloc (thread->callee_time_stack, thread->stack_size * sizeof (uint64_t));
}
}
trace->size *= 2;
if (trace->size == 0)
trace->size = 4;
- n = calloc (sizeof (CallContext) * trace->size, 1);
+ n = (CallContext *)calloc (sizeof (CallContext) * trace->size, 1);
for (i = 0; i < old_size; ++i) {
if (trace->traces [i].bt)
add_trace_hashed (n, trace->size, trace->traces [i].bt, trace->traces [i].count);
int new_size = ctx->size_roots * 2;
if (!new_size)
new_size = 4;
- ctx->roots = realloc (ctx->roots, new_size * sizeof (uintptr_t));
- ctx->roots_extra = realloc (ctx->roots_extra, new_size * sizeof (uintptr_t));
- ctx->roots_types = realloc (ctx->roots_types, new_size * sizeof (int));
+ ctx->roots = (uintptr_t *)realloc (ctx->roots, new_size * sizeof (uintptr_t));
+ ctx->roots_extra = (uintptr_t *)realloc (ctx->roots_extra, new_size * sizeof (uintptr_t));
+ ctx->roots_types = (int *)realloc (ctx->roots_types, new_size * sizeof (int));
ctx->size_roots = new_size;
}
ctx->roots_types [ctx->num_roots] = root_type;
static int
compare_callc (const void *a, const void *b)
{
- const CallContext *A = a;
- const CallContext *B = b;
+ const CallContext *A = (const CallContext *)a;
+ const CallContext *B = (const CallContext *)b;
if (B->count == A->count)
return 0;
if (B->count < A->count)
while (cd && cd->objid != objid)
cd = cd->next;
if (!cd) {
- cd = calloc (sizeof (MonitorDesc), 1);
+ cd = (MonitorDesc *)calloc (sizeof (MonitorDesc), 1);
cd->objid = objid;
cd->next = monitor_hash [slot];
monitor_hash [slot] = cd;
if (flags != 0)
return NULL;
if (count > *size)
- frames = malloc (count * sizeof (void*));
+ frames = (MethodDesc **)malloc (count * sizeof (void*));
else
frames = sframes;
for (i = 0; i < count; ++i) {
found_object (uintptr_t obj)
{
num_tracked_objects ++;
- tracked_objects = realloc (tracked_objects, num_tracked_objects * sizeof (tracked_objects [0]));
+ tracked_objects = (uintptr_t *)realloc (tracked_objects, num_tracked_objects * sizeof (tracked_objects [0]));
tracked_objects [num_tracked_objects - 1] = obj;
}
gather_coverage_statements (void)
{
for (guint i = 0; i < coverage_statements->len; i++) {
- CoverageCoverage *coverage = coverage_statements->pdata[i];
- CoverageMethod *method = g_hash_table_lookup (coverage_methods_hash, GINT_TO_POINTER (coverage->method_id));
+ CoverageCoverage *coverage = (CoverageCoverage *)coverage_statements->pdata[i];
+ CoverageMethod *method = (CoverageMethod *)g_hash_table_lookup (coverage_methods_hash, GINT_TO_POINTER (coverage->method_id));
if (method == NULL) {
fprintf (outfile, "Cannot find method with ID: %d\n", coverage->method_id);
continue;
}
g_ptr_array_add (coverage_classes, klass);
- classes = g_hash_table_lookup (coverage_assembly_classes, klass->assembly_name);
+ classes = (GPtrArray *)g_hash_table_lookup (coverage_assembly_classes, klass->assembly_name);
if (classes == NULL) {
classes = g_ptr_array_new ();
g_hash_table_insert (coverage_assembly_classes, klass->assembly_name, classes);
int codelen = decode_uleb128 (p, &p);
const char *name;
if (type == MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE) {
- name = (void*)p;
+ name = (const char *)p;
while (*p) p++;
p++;
} else {
type = decode_uleb128 (p, &p);
- value = calloc (1, sizeof (CounterValue));
+ value = (CounterValue *)calloc (1, sizeof (CounterValue));
value->timestamp = timestamp;
switch (type) {
#if SIZEOF_VOID_P == 4
case MONO_COUNTER_WORD:
#endif
- value->buffer = malloc (sizeof (int32_t));
+ value->buffer = (unsigned char *)malloc (sizeof (int32_t));
*(int32_t*)value->buffer = (int32_t)decode_sleb128 (p, &p) + (previous ? (*(int32_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_UINT:
- value->buffer = malloc (sizeof (uint32_t));
+ value->buffer = (unsigned char *)malloc (sizeof (uint32_t));
*(uint32_t*)value->buffer = (uint32_t)decode_uleb128 (p, &p) + (previous ? (*(uint32_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_LONG:
case MONO_COUNTER_WORD:
#endif
case MONO_COUNTER_TIME_INTERVAL:
- value->buffer = malloc (sizeof (int64_t));
+ value->buffer = (unsigned char *)malloc (sizeof (int64_t));
*(int64_t*)value->buffer = (int64_t)decode_sleb128 (p, &p) + (previous ? (*(int64_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_ULONG:
- value->buffer = malloc (sizeof (uint64_t));
+ value->buffer = (unsigned char *)malloc (sizeof (uint64_t));
*(uint64_t*)value->buffer = (uint64_t)decode_uleb128 (p, &p) + (previous ? (*(uint64_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_DOUBLE:
- value->buffer = malloc (sizeof (double));
+ value->buffer = (unsigned char *)malloc (sizeof (double));
#if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
for (i = 0; i < sizeof (double); i++)
#else
int token, n_offsets, method_id;
p++;
- assembly = (void *)p; while (*p) p++; p++;
- klass = (void *)p; while (*p) p++; p++;
- name = (void *)p; while (*p) p++; p++;
- sig = (void *)p; while (*p) p++; p++;
- filename = (void *)p; while (*p) p++; p++;
+ assembly = (const char *)p; while (*p) p++; p++;
+ klass = (const char *)p; while (*p) p++; p++;
+ name = (const char *)p; while (*p) p++; p++;
+ sig = (const char *)p; while (*p) p++; p++;
+ filename = (const char *)p; while (*p) p++; p++;
token = decode_uleb128 (p, &p);
method_id = decode_uleb128 (p, &p);
int number_of_methods, fully_covered, partially_covered;
p++;
- name = (void *)p; while (*p) p++; p++;
- guid = (void *)p; while (*p) p++; p++;
- filename = (void *)p; while (*p) p++; p++;
+ name = (char *)p; while (*p) p++; p++;
+ guid = (char *)p; while (*p) p++; p++;
+ filename = (char *)p; while (*p) p++; p++;
number_of_methods = decode_uleb128 (p, &p);
fully_covered = decode_uleb128 (p, &p);
partially_covered = decode_uleb128 (p, &p);
int number_of_methods, fully_covered, partially_covered;
p++;
- assembly_name = (void *)p; while (*p) p++; p++;
- class_name = (void *)p; while (*p) p++; p++;
+ assembly_name = (char *)p; while (*p) p++; p++;
+ class_name = (char *)p; while (*p) p++; p++;
number_of_methods = decode_uleb128 (p, &p);
fully_covered = decode_uleb128 (p, &p);
partially_covered = decode_uleb128 (p, &p);
load_file (char *name)
{
unsigned char *p;
- ProfContext *ctx = calloc (sizeof (ProfContext), 1);
+ ProfContext *ctx = (ProfContext *)calloc (sizeof (ProfContext), 1);
if (strcmp (name, "-") == 0)
ctx->file = stdin;
else
static int
compare_class (const void *a, const void *b)
{
- ClassDesc *const*A = a;
- ClassDesc *const*B = b;
+ ClassDesc *const *A = (ClassDesc *const *)a;
+ ClassDesc *const *B = (ClassDesc *const *)b;
uint64_t vala, valb;
if (alloc_sort_mode == ALLOC_SORT_BYTES) {
vala = (*A)->alloc_size;
static int
compare_monitor (const void *a, const void *b)
{
- MonitorDesc *const*A = a;
- MonitorDesc *const*B = b;
+ MonitorDesc *const *A = (MonitorDesc *const *)a;
+ MonitorDesc *const *B = (MonitorDesc *const *)b;
if ((*B)->wait_time == (*A)->wait_time)
return 0;
if ((*B)->wait_time < (*A)->wait_time)
int i, j;
if (!num_monitors)
return;
- monitors = malloc (sizeof (void*) * num_monitors);
+ monitors = (MonitorDesc **)malloc (sizeof (void*) * num_monitors);
for (i = 0, j = 0; i < SMALL_HASH_SIZE; ++i) {
MonitorDesc *mdesc = monitor_hash [i];
while (mdesc) {
intptr_t allocs = 0;
uint64_t size = 0;
int header_done = 0;
- ClassDesc **classes = malloc (num_classes * sizeof (void*));
+ ClassDesc **classes = (ClassDesc **)malloc (num_classes * sizeof (void*));
ClassDesc *cd;
c = 0;
for (i = 0; i < HASH_SIZE; ++i) {
static int
compare_method (const void *a, const void *b)
{
- MethodDesc *const*A = a;
- MethodDesc *const*B = b;
+ MethodDesc *const *A = (MethodDesc *const *)a;
+ MethodDesc *const *B = (MethodDesc *const *)b;
uint64_t vala, valb;
if (method_sort_mode == METHOD_SORT_SELF) {
vala = (*A)->self_time;
int i, c;
uint64_t calls = 0;
int header_done = 0;
- MethodDesc **methods = malloc (num_methods * sizeof (void*));
+ MethodDesc **methods = (MethodDesc **)malloc (num_methods * sizeof (void*));
MethodDesc *cd;
c = 0;
for (i = 0; i < HASH_SIZE; ++i) {
static int
compare_heap_class (const void *a, const void *b)
{
- HeapClassDesc *const*A = a;
- HeapClassDesc *const*B = b;
+ HeapClassDesc *const *A = (HeapClassDesc *const *)a;
+ HeapClassDesc *const *B = (HeapClassDesc *const *)b;
uint64_t vala, valb;
if (alloc_sort_mode == ALLOC_SORT_BYTES) {
vala = (*A)->total_size;
static int
compare_rev_class (const void *a, const void *b)
{
- const HeapClassRevRef *A = a;
- const HeapClassRevRef *B = b;
+ const HeapClassRevRef *A = (const HeapClassRevRef *)a;
+ const HeapClassRevRef *B = (const HeapClassRevRef *)b;
if (B->count == A->count)
return 0;
if (B->count < A->count)
int i;
HeapClassDesc *cd;
HeapClassDesc **sorted;
- sorted = malloc (sizeof (void*) * hs->class_count);
+ sorted = (HeapClassDesc **)malloc (sizeof (void*) * hs->class_count);
for (i = 0; i < hs->hash_size; ++i) {
cd = hs->class_hash [i];
if (!cd)
}
if (!collect_traces)
continue;
- rev_sorted = malloc (cd->rev_count * sizeof (HeapClassRevRef));
+ rev_sorted = (HeapClassRevRef *)malloc (cd->rev_count * sizeof (HeapClassRevRef));
k = 0;
for (j = 0; j < cd->rev_hash_size; ++j) {
if (cd->rev_hash [j].klass)
static int
compare_heap_shots (const void *a, const void *b)
{
- HeapShot *const*A = a;
- HeapShot *const*B = b;
+ HeapShot *const *A = (HeapShot *const *)a;
+ HeapShot *const *B = (HeapShot *const *)b;
if ((*B)->timestamp == (*A)->timestamp)
return 0;
if ((*B)->timestamp > (*A)->timestamp)
int i;
if (!heap_shots)
return;
- hs_sorted = malloc (num_heap_shots * sizeof (void*));
+ hs_sorted = (HeapShot **)malloc (num_heap_shots * sizeof (void*));
fprintf (outfile, "\nHeap shot summary\n");
i = 0;
for (hs = heap_shots; hs; hs = hs->next)
g_ptr_array_sort (coverage_assemblies, sort_assemblies);
for (guint i = 0; i < coverage_assemblies->len; i++) {
- CoverageAssembly *assembly = coverage_assemblies->pdata[i];
+ CoverageAssembly *assembly = (CoverageAssembly *)coverage_assemblies->pdata[i];
GPtrArray *classes;
if (assembly->number_of_methods != 0) {
g_free (escaped_filename);
}
- classes = g_hash_table_lookup (coverage_assembly_classes, assembly->name);
+ classes = (GPtrArray *)g_hash_table_lookup (coverage_assembly_classes, assembly->name);
if (classes) {
for (guint j = 0; j < classes->len; j++) {
- CoverageClass *klass = classes->pdata[j];
+ CoverageClass *klass = (CoverageClass *)classes->pdata [j];
if (klass->number_of_methods > 0) {
int percentage = ((klass->fully_covered + klass->partially_covered) * 100) / klass->number_of_methods;
}
for (guint i = 0; i < coverage_methods->len; i++) {
- CoverageMethod *method = coverage_methods->pdata[i];
+ CoverageMethod *method = (CoverageMethod *)coverage_methods->pdata [i];
if (coverage_outfile) {
char *escaped_assembly, *escaped_class, *escaped_method, *escaped_sig, *escaped_filename;
g_free (escaped_filename);
for (guint j = 0; j < method->coverage->len; j++) {
- CoverageCoverage *coverage = method->coverage->pdata[j];
+ CoverageCoverage *coverage = (CoverageCoverage *)method->coverage->pdata [j];
fprintf (coverage_outfile, "\t\t<statement offset=\"%d\" counter=\"%d\" line=\"%d\" column=\"%d\"/>\n", coverage->offset, coverage->count, coverage->line, coverage->column);
}
fprintf (coverage_outfile, "\t</method>\n");
MonoImage *image = mono_class_get_image (mono_method_get_class (method));
PerImageData *data;
- data = g_hash_table_lookup (prof->images, image);
+ data = (PerImageData *)g_hash_table_lookup (prof->images, image);
if (!data) {
data = g_new0 (PerImageData, 1);
g_hash_table_insert (prof->images, image, data);
return;
}
- location = g_hash_table_lookup (prof->string_locations_hash, &hash);
+ location = (StringLocation *)g_hash_table_lookup (prof->string_locations_hash, &hash);
while (location) {
if (location->hint && strlen (location->hint) > 0) {
if (!bannerShown) {
static inline void store_string_location (MonoProfiler *prof, const gchar *string, guint32 hash, size_t len)
{
- StringLocation *location = g_hash_table_lookup (prof->string_locations_hash, &hash);
+ StringLocation *location = (StringLocation *)g_hash_table_lookup (prof->string_locations_hash, &hash);
SavedString *saved;
SavedStringFindInfo info;
guint32 *hashptr;
mono_profiler_install_iomap (mono_portability_iomap_event);
mono_profiler_install_allocation (mono_portability_remember_alloc);
- mono_profiler_set_events (MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_IOMAP_EVENTS);
+ mono_profiler_set_events ((MonoProfileFlags)(MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_IOMAP_EVENTS));
}
pstrdup (const char *s)
{
int len = strlen (s) + 1;
- char *p = malloc (len);
+ char *p = (char *)malloc (len);
memcpy (p, s, len);
return p;
}
static StatBuffer*
create_stat_buffer (void)
{
- StatBuffer* buf = alloc_buffer (BUFFER_SIZE);
+ StatBuffer* buf = (StatBuffer *)alloc_buffer (BUFFER_SIZE);
buf->size = BUFFER_SIZE;
buf->data_end = (uintptr_t*)((unsigned char*)buf + buf->size);
buf->data = buf->buf;
static LogBuffer*
create_buffer (void)
{
- LogBuffer* buf = alloc_buffer (BUFFER_SIZE);
+ LogBuffer* buf = (LogBuffer *)alloc_buffer (BUFFER_SIZE);
buf->size = BUFFER_SIZE;
buf->time_base = current_time ();
buf->last_time = buf->time_base;
if (old && old->data + bytes + 100 < old->data_end)
return old;
- LogBuffer *new = create_buffer ();
- new->thread_id = thread_id ();
- new->next = old;
+ LogBuffer *new_ = (LogBuffer *)create_buffer ();
+ new_->thread_id = thread_id ();
+ new_->next = old;
if (old)
- new->call_depth = old->call_depth;
+ new_->call_depth = old->call_depth;
- return new;
+ return new_;
}
static LogBuffer*
ensure_logbuf (int bytes)
{
LogBuffer *old = TLS_GET (LogBuffer, tlsbuffer);
- LogBuffer *new = ensure_logbuf_inner (old, bytes);
+ LogBuffer *new_ = ensure_logbuf_inner (old, bytes);
- if (new == old)
+ if (new_ == old)
return old; // Still enough space.
- TLS_SET (tlsbuffer, new);
+ TLS_SET (tlsbuffer, new_);
init_thread ();
- return new;
+ return new_;
}
static void
*/
//g_assert (ji);
- MethodInfo *info = malloc (sizeof (MethodInfo));
+ MethodInfo *info = (MethodInfo *)malloc (sizeof (MethodInfo));
info->method = method;
info->ji = ji;
static void
send_buffer (MonoProfiler *prof, GPtrArray *methods, LogBuffer *buffer)
{
- WriterQueueEntry *entry = calloc (1, sizeof (WriterQueueEntry));
+ WriterQueueEntry *entry = (WriterQueueEntry *)calloc (1, sizeof (WriterQueueEntry));
mono_lock_free_queue_node_init (&entry->node, FALSE);
entry->methods = methods;
entry->buffer = buffer;
static mono_bool
walk_stack (MonoMethod *method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data)
{
- FrameData *frame = data;
+ FrameData *frame = (FrameData *)data;
if (method && frame->count < num_frames) {
frame->il_offsets [frame->count] = il_offset;
frame->native_offsets [frame->count] = native_offset;
char buf [1024];
char *p;
push_nesting (buf, klass);
- p = malloc (strlen (buf) + 1);
+ p = (char *)malloc (strlen (buf) + 1);
strcpy (p, buf);
return p;
}
char *name;
LogBuffer *logbuffer;
if (type == MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE) {
- name = data;
+ name = (char *)data;
nlen = strlen (name) + 1;
} else {
name = NULL;
static mono_bool
async_walk_stack (MonoMethod *method, MonoDomain *domain, void *base_address, int offset, void *data)
{
- AsyncFrameData *frame = data;
+ AsyncFrameData *frame = (AsyncFrameData *)data;
if (frame->count < num_frames) {
frame->data [frame->count].method = method;
frame->data [frame->count].domain = domain;
do {
oldsb = profiler->stat_buffers;
sbuf->next = oldsb;
- foundsb = InterlockedCompareExchangePointer ((void * volatile*)&profiler->stat_buffers, sbuf, oldsb);
+ foundsb = (StatBuffer *)InterlockedCompareExchangePointer ((void * volatile*)&profiler->stat_buffers, sbuf, oldsb);
} while (foundsb != oldsb);
if (do_debug)
ign_res (write (2, "overflow\n", 9));
do {
old_data = sbuf->data;
new_data = old_data + SAMPLE_EVENT_SIZE_IN_SLOTS (bt_data.count);
- data = InterlockedCompareExchangePointer ((void * volatile*)&sbuf->data, new_data, old_data);
+ data = (uintptr_t *)InterlockedCompareExchangePointer ((void * volatile*)&sbuf->data, new_data, old_data);
} while (data != old_data);
if (old_data >= sbuf->data_end)
return; /* lost event */
size_code_pages *= 2;
if (size_code_pages == 0)
size_code_pages = 16;
- n = calloc (sizeof (uintptr_t) * size_code_pages, 1);
+ n = (uintptr_t *)calloc (sizeof (uintptr_t) * size_code_pages, 1);
for (i = 0; i < old_size; ++i) {
if (code_pages [i])
add_code_page (n, size_code_pages, code_pages [i]);
g_ptr_array_sort (prof->sorted_sample_events, compare_sample_events);
for (guint sidx = 0; sidx < prof->sorted_sample_events->len; sidx++) {
- uintptr_t *sample = g_ptr_array_index (prof->sorted_sample_events, sidx);
+ uintptr_t *sample = (uintptr_t *)g_ptr_array_index (prof->sorted_sample_events, sidx);
int count = sample [0] & 0xff;
int mbt_count = (sample [0] & 0xff00) >> 8;
int type = sample [0] >> 16;
void *address = (void*)managed_sample_base [i * 4 + 2];
if (!method) {
- MonoJitInfo *ji = mono_jit_info_table_find (domain, address);
+ MonoJitInfo *ji = mono_jit_info_table_find (domain, (char *)address);
if (ji)
managed_sample_base [i * 4 + 0] = (uintptr_t)mono_jit_info_get_method (ji);
}
}
- agent = malloc (sizeof (MonoCounterAgent));
+ agent = (MonoCounterAgent *)malloc (sizeof (MonoCounterAgent));
agent->counter = counter;
agent->value = NULL;
agent->value_size = 0;
if (name == NULL || *name == '\0')
return g_strdup ("");
- if (!(ret = new_name = calloc (strlen (name) * 4 + 1, sizeof (char))))
+ if (!(ret = new_name = (char *)calloc (strlen (name) * 4 + 1, sizeof (char))))
return NULL;
do {
method_name = mono_method_get_name (method);
if (coverage_data->len != 0) {
- CoverageEntry *entry = coverage_data->pdata[0];
+ CoverageEntry *entry = (CoverageEntry *)coverage_data->pdata[0];
first_filename = entry->filename ? entry->filename : "";
} else
first_filename = "";
safe_send (prof, logbuffer);
for (i = 0; i < coverage_data->len; i++) {
- CoverageEntry *entry = coverage_data->pdata[i];
+ CoverageEntry *entry = (CoverageEntry *)coverage_data->pdata[i];
logbuffer = ensure_logbuf (
EVENT_SIZE /* event */ +
static void
get_coverage_for_image (MonoImage *image, int *number_of_methods, guint *fully_covered, int *partially_covered)
{
- MonoLockFreeQueue *image_methods = mono_conc_hashtable_lookup (image_to_methods, image);
+ MonoLockFreeQueue *image_methods = (MonoLockFreeQueue *)mono_conc_hashtable_lookup (image_to_methods, image);
*number_of_methods = mono_image_get_table_rows (image, MONO_TABLE_METHOD);
if (image_methods)
static MonoLockFreeQueueNode *
create_method_node (MonoMethod *method)
{
- MethodNode *node = g_malloc (sizeof (MethodNode));
+ MethodNode *node = (MethodNode *)g_malloc (sizeof (MethodNode));
mono_lock_free_queue_node_init ((MonoLockFreeQueueNode *) node, FALSE);
node->method = method;
has_positive = FALSE;
found = FALSE;
for (guint i = 0; i < prof->coverage_filters->len; ++i) {
- char *filter = g_ptr_array_index (prof->coverage_filters, i);
+ char *filter = (char *)g_ptr_array_index (prof->coverage_filters, i);
if (filter [0] == '+') {
filter = &filter [1];
for (guint i = 0; i < prof->coverage_filters->len; ++i) {
// FIXME: Is substring search sufficient?
- char *filter = g_ptr_array_index (prof->coverage_filters, i);
+ char *filter = (char *)g_ptr_array_index (prof->coverage_filters, i);
if (filter [0] == '+')
continue;
mono_conc_hashtable_insert (coverage_assemblies, assembly, assembly);
mono_os_mutex_unlock (&coverage_mutex);
- image_methods = mono_conc_hashtable_lookup (image_to_methods, image);
+ image_methods = (MonoLockFreeQueue *)mono_conc_hashtable_lookup (image_to_methods, image);
if (image_methods == NULL) {
- image_methods = g_malloc (sizeof (MonoLockFreeQueue));
+ image_methods = (MonoLockFreeQueue *)g_malloc (sizeof (MonoLockFreeQueue));
mono_lock_free_queue_init (image_methods);
mono_os_mutex_lock (&coverage_mutex);
mono_conc_hashtable_insert (image_to_methods, image, image_methods);
node = create_method_node (method);
mono_lock_free_queue_enqueue (image_methods, node);
- class_methods = mono_conc_hashtable_lookup (coverage_classes, klass);
+ class_methods = (MonoLockFreeQueue *)mono_conc_hashtable_lookup (coverage_classes, klass);
if (class_methods == NULL) {
- class_methods = g_malloc (sizeof (MonoLockFreeQueue));
+ class_methods = (MonoLockFreeQueue *)g_malloc (sizeof (MonoLockFreeQueue));
mono_lock_free_queue_init (class_methods);
mono_os_mutex_lock (&coverage_mutex);
mono_conc_hashtable_insert (coverage_classes, klass, class_methods);
if (filesize > MAX_FILE_SIZE)
return NULL;
- buffer = g_malloc ((filesize + 1) * sizeof (char));
+ buffer = (char *)g_malloc ((filesize + 1) * sizeof (char));
while ((bytes_read = fread (buffer + offset, 1, LINE_BUFFER_SIZE, stream)) > 0)
offset += bytes_read;
1900 + ts->tm_year, 1 + ts->tm_mon, ts->tm_mday, ts->tm_hour, ts->tm_min, ts->tm_sec);
s_date = strlen (time_buf);
s_pid = strlen (pid_buf);
- d = res = malloc (strlen (filename) + s_date * count_dates + s_pid * count_pids);
+ d = res = (char *)malloc (strlen (filename) + s_date * count_dates + s_pid * count_pids);
for (p = filename; *p; p++) {
if (*p != '%') {
*d++ = *p;
static void*
helper_thread (void* arg)
{
- MonoProfiler* prof = arg;
+ MonoProfiler* prof = (MonoProfiler *)arg;
int command_socket;
int len;
char buf [64];
static void *
writer_thread (void *arg)
{
- MonoProfiler *prof = arg;
+ MonoProfiler *prof = (MonoProfiler *)arg;
mono_threads_attach_tools_thread ();
* methods have metadata emitted before they're referenced.
*/
for (guint i = 0; i < entry->methods->len; i++) {
- MethodInfo *info = g_ptr_array_index (entry->methods, i);
+ MethodInfo *info = (MethodInfo *)g_ptr_array_index (entry->methods, i);
if (mono_conc_hashtable_lookup (prof->method_table, info->method))
continue;
MonoProfiler *prof;
char *nf;
int force_delete = 0;
- prof = calloc (1, sizeof (MonoProfiler));
+ prof = (MonoProfiler *)calloc (1, sizeof (MonoProfiler));
prof->command_port = command_port;
if (filename && *filename == '-') {
nf = new_filename (filename);
if (do_report) {
int s = strlen (nf) + 32;
- char *p = malloc (s);
+ char *p = (char *)malloc (s);
snprintf (p, s, "|mprof-report '--out=%s' -", nf);
free (nf);
nf = p;
} else {
l = end - opt;
}
- val = malloc (l + 1);
+ val = (char *)malloc (l + 1);
memcpy (val, opt, l);
val [l] = 0;
*rval = val;
mono_profiler_install_statistical (mono_sample_hit);
}
- mono_profiler_set_events (events);
+ mono_profiler_set_events ((MonoProfileFlags)events);
TLS_INIT (tlsbuffer);
TLS_INIT (tlsmethodlist);
#define MONO_GC_HANDLE_TYPE_SHIFT (3)
#define MONO_GC_HANDLE_TYPE_MASK ((1 << MONO_GC_HANDLE_TYPE_SHIFT) - 1)
-#define MONO_GC_HANDLE_TYPE(x) (((x) & MONO_GC_HANDLE_TYPE_MASK) - 1)
+#define MONO_GC_HANDLE_TYPE(x) ((GCHandleType)(((x) & MONO_GC_HANDLE_TYPE_MASK) - 1))
#define MONO_GC_HANDLE_SLOT(x) ((x) >> MONO_GC_HANDLE_TYPE_SHIFT)
#define MONO_GC_HANDLE_TYPE_IS_WEAK(x) ((x) <= HANDLE_WEAK_TRACK)
#define MONO_GC_HANDLE(slot, type) (((slot) << MONO_GC_HANDLE_TYPE_SHIFT) | (((type) & MONO_GC_HANDLE_TYPE_MASK) + 1))
*/
if (real_size > SGEN_MAX_SMALL_OBJ_SIZE) {
- p = sgen_los_alloc_large_inner (vtable, ALIGN_UP (real_size));
+ p = (void **)sgen_los_alloc_large_inner (vtable, ALIGN_UP (real_size));
} else {
/* tlab_next and tlab_temp_end are TLS vars so accessing them might be expensive */
available_in_tlab = (int)(TLAB_REAL_END - TLAB_NEXT);//We'll never have tlabs > 2Gb
if (size > tlab_size || available_in_tlab > SGEN_MAX_NURSERY_WASTE) {
/* Allocate directly from the nursery */
- p = sgen_nursery_alloc (size);
+ p = (void **)sgen_nursery_alloc (size);
if (!p) {
/*
* We couldn't allocate from the nursery, so we try
*/
sgen_ensure_free_space (real_size);
if (!degraded_mode)
- p = sgen_nursery_alloc (size);
+ p = (void **)sgen_nursery_alloc (size);
}
if (!p)
return alloc_degraded (vtable, size, FALSE);
SGEN_LOG (3, "Retire TLAB: %p-%p [%ld]", TLAB_START, TLAB_REAL_END, (long)(TLAB_REAL_END - TLAB_NEXT - size));
sgen_nursery_retire_region (p, available_in_tlab);
- p = sgen_nursery_alloc_range (tlab_size, size, &alloc_size);
+ p = (void **)sgen_nursery_alloc_range (tlab_size, size, &alloc_size);
if (!p) {
/* See comment above in similar case. */
sgen_ensure_free_space (tlab_size);
if (!degraded_mode)
- p = sgen_nursery_alloc_range (tlab_size, size, &alloc_size);
+ p = (void **)sgen_nursery_alloc_range (tlab_size, size, &alloc_size);
}
if (!p)
return alloc_degraded (vtable, size, FALSE);
zero_tlab_if_necessary (TLAB_START, alloc_size);
/* Allocate from the TLAB */
- p = (void*)TLAB_NEXT;
+ p = (void **)TLAB_NEXT;
TLAB_NEXT += size;
sgen_set_nursery_scan_start ((char*)p);
}
if (G_UNLIKELY (size > tlab_size)) {
/* Allocate directly from the nursery */
- p = sgen_nursery_alloc (size);
+ p = (void **)sgen_nursery_alloc (size);
if (!p)
return NULL;
sgen_set_nursery_scan_start ((char*)p);
}
} else if (available_in_tlab > SGEN_MAX_NURSERY_WASTE) {
/* Allocate directly from the nursery */
- p = sgen_nursery_alloc (size);
+ p = (void **)sgen_nursery_alloc (size);
if (!p)
return NULL;
size_t alloc_size = 0;
sgen_nursery_retire_region (p, available_in_tlab);
- new_next = sgen_nursery_alloc_range (tlab_size, size, &alloc_size);
+ new_next = (char *)sgen_nursery_alloc_range (tlab_size, size, &alloc_size);
p = (void**)new_next;
if (!p)
return NULL;
if (size > SGEN_MAX_SMALL_OBJ_SIZE) {
/* large objects are always pinned anyway */
- p = sgen_los_alloc_large_inner (vtable, size);
+ p = (GCObject *)sgen_los_alloc_large_inner (vtable, size);
} else {
SGEN_ASSERT (9, sgen_client_vtable_is_inited (vtable), "class %s:%s is not initialized", sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable));
p = major_collector.alloc_small_pinned_obj (vtable, size, SGEN_VTABLE_HAS_REFERENCES (vtable));
static void
sgen_card_table_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
{
- gpointer *dest = dest_ptr;
- gpointer *src = src_ptr;
+ gpointer *dest = (gpointer *)dest_ptr;
+ gpointer *src = (gpointer *)src_ptr;
/*overlapping that required backward copying*/
if (src < dest && (src + count) > dest) {
static gboolean
sgen_card_table_find_address_with_cards (char *cards_start, guint8 *cards, char *addr)
{
- cards_start = sgen_card_table_align_pointer (cards_start);
+ cards_start = (char *)sgen_card_table_align_pointer (cards_start);
return cards [(addr - cards_start) >> CARD_BITS];
}
sgen_card_table_alloc_mod_union (char *obj, mword obj_size)
{
size_t num_cards = sgen_card_table_number_of_cards_in_range ((mword) obj, obj_size);
- guint8 *mod_union = sgen_alloc_internal_dynamic (num_cards, INTERNAL_MEM_CARDTABLE_MOD_UNION, TRUE);
+ guint8 *mod_union = (guint8 *)sgen_alloc_internal_dynamic (num_cards, INTERNAL_MEM_CARDTABLE_MOD_UNION, TRUE);
memset (mod_union, 0, num_cards);
return mod_union;
}
void
sgen_card_table_init (SgenRememberedSet *remset)
{
- sgen_cardtable = sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "card table");
+ sgen_cardtable = (guint8 *)sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, (SgenAllocFlags)(SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE), "card table");
#ifdef SGEN_HAVE_OVERLAPPING_CARDS
- sgen_shadow_cardtable = sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "shadow card table");
+ sgen_shadow_cardtable = (guint8 *)sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, (SgenAllocFlags)(SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE), "shadow card table");
#endif
#ifdef HEAVY_STATISTICS
obj = destination;
if (queue) {
SGEN_LOG (9, "Enqueuing gray object %p (%s)", obj, sgen_client_vtable_get_name (vt));
- GRAY_OBJECT_ENQUEUE (queue, obj, sgen_vtable_get_descriptor (vt));
+ GRAY_OBJECT_ENQUEUE (queue, (GCObject *)obj, sgen_vtable_get_descriptor (vt));
}
}
/*
* This can return OBJ itself on OOM.
*/
-static MONO_NEVER_INLINE void*
-copy_object_no_checks (void *obj, SgenGrayQueue *queue)
+static MONO_NEVER_INLINE GCObject *
+copy_object_no_checks (GCObject *obj, SgenGrayQueue *queue)
{
GCVTable vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
gboolean has_references = SGEN_VTABLE_HAS_REFERENCES (vt);
if (!has_references)
queue = NULL;
- par_copy_object_no_checks (destination, vt, obj, objsize, queue);
+ par_copy_object_no_checks ((char *)destination, vt, obj, objsize, queue);
/* FIXME: mark mod union cards if necessary */
/* set the forwarding pointer */
SGEN_FORWARD_OBJECT (obj, destination);
- return destination;
+ return (GCObject *)destination;
}
if (object_is_pinned (ptr))
printf ("Object is pinned.\n");
- if ((forwarded = object_is_forwarded (ptr))) {
+ if ((forwarded = (char *)object_is_forwarded (ptr))) {
printf ("Object is forwarded to %p:\n", forwarded);
ptr = forwarded;
goto restart;
setup_valid_nursery_objects (void)
{
if (!valid_nursery_objects)
- valid_nursery_objects = sgen_alloc_os_memory (DEFAULT_NURSERY_SIZE, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging data");
+ valid_nursery_objects = (GCObject **)sgen_alloc_os_memory (DEFAULT_NURSERY_SIZE, (SgenAllocFlags)(SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE), "debugging data");
valid_nursery_object_count = 0;
sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data, setup_mono_sgen_scan_area_with_callback, NULL, FALSE, FALSE);
}
RootRecord *root;
char *endobj = obj + size;
- SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_NORMAL], start, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_NORMAL], char **, start, RootRecord *, root) {
/* if desc is non-null it has precise info */
if (!root->root_desc) {
while (start < (char**)root->end_root) {
RootRecord *root;
check_key = key;
- SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
SgenDescriptor desc = root->root_desc;
check_root = root;
desc >>= ROOT_DESC_TYPE_SHIFT;
while (desc) {
if (desc & 1)
- check_root_obj_specific_ref (root, key, *start_root);
+ check_root_obj_specific_ref (root, key, (GCObject *)*start_root);
desc >>= 1;
start_root++;
}
return;
case ROOT_DESC_COMPLEX: {
- gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
+ gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
int bwords = (int) ((*bitmap_data) - 1);
void **start_run = start_root;
bitmap_data++;
void **objptr = start_run;
while (bmap) {
if (bmap & 1)
- check_root_obj_specific_ref (root, key, *objptr);
+ check_root_obj_specific_ref (root, key, (GCObject *)*objptr);
bmap >>= 1;
++objptr;
}
scan_roots_for_specific_ref (key, ROOT_TYPE_NORMAL);
scan_roots_for_specific_ref (key, ROOT_TYPE_WBARRIER);
- SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], ptr, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], void **, ptr, RootRecord *, root) {
while (ptr < (void**)root->end_root) {
- check_root_obj_specific_ref (root, *ptr, key);
+ check_root_obj_specific_ref (root, (GCObject *)*ptr, key);
++ptr;
}
} SGEN_HASH_TABLE_FOREACH_END;
void **start_root;
RootRecord *root;
check_domain = domain;
- SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
SgenDescriptor desc = root->root_desc;
/* The MonoDomain struct is allowed to hold
desc >>= ROOT_DESC_TYPE_SHIFT;
while (desc) {
if ((desc & 1) && *start_root)
- check_obj_not_in_domain (*start_root);
+ check_obj_not_in_domain ((MonoObject **)*start_root);
desc >>= 1;
start_root++;
}
break;
case ROOT_DESC_COMPLEX: {
- gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
+ gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
int bwords = (int)((*bitmap_data) - 1);
void **start_run = start_root;
bitmap_data++;
void **objptr = start_run;
while (bmap) {
if ((bmap & 1) && *objptr)
- check_obj_not_in_domain (*objptr);
+ check_obj_not_in_domain ((MonoObject **)*objptr);
bmap >>= 1;
++objptr;
}
{
MonoObject *ref = *ptr;
size_t offset = (char*)(ptr) - (char*)obj;
- MonoClass *class;
+ MonoClass *klass;
MonoClassField *field;
char *str;
return;
field = NULL;
- for (class = obj->vtable->klass; class; class = class->parent) {
+ for (klass = obj->vtable->klass; klass; klass = klass->parent) {
int i;
- for (i = 0; i < class->field.count; ++i) {
- if (class->fields[i].offset == offset) {
- field = &class->fields[i];
+ for (i = 0; i < klass->field.count; ++i) {
+ if (klass->fields[i].offset == offset) {
+ field = &klass->fields[i];
break;
}
}
#ifndef SGEN_WITHOUT_MONO
static char class_name [1024];
- MonoClass *class = mono_object_class (obj);
+ MonoClass *klass = mono_object_class (obj);
int i, j;
/*
* in strings, so we just ignore them;
*/
i = j = 0;
- while (class->name [i] && j < sizeof (class_name) - 1) {
- if (!strchr ("<>\"", class->name [i]))
- class_name [j++] = class->name [i];
+ while (klass->name [i] && j < sizeof (class_name) - 1) {
+ if (!strchr ("<>\"", klass->name [i]))
+ class_name [j++] = klass->name [i];
++i;
}
g_assert (j < sizeof (class_name));
class_name [j] = 0;
fprintf (heap_dump_file, "<object class=\"%s.%s\" size=\"%zd\"",
- class->name_space, class_name,
+ klass->name_space, class_name,
safe_object_get_size (obj));
if (dump_location) {
const char *location;
fprintf (heap_dump_file, "<pinned-objects>\n");
pinned_objects = sgen_pin_stats_get_object_list ();
for (i = 0; i < pinned_objects->next_slot; ++i)
- dump_object (pinned_objects->data [i], TRUE);
+ dump_object ((GCObject *)pinned_objects->data [i], TRUE);
fprintf (heap_dump_file, "</pinned-objects>\n");
sgen_dump_section (nursery_section, "nursery");
static void
find_object_for_ptr_callback (GCObject *obj, size_t size, void *user_data)
{
- char *ptr = user_data;
+ char *ptr = (char *)user_data;
if (ptr >= (char*)obj && ptr < (char*)obj + size) {
g_assert (!found_obj);
}
if (complex_descriptors_next + nwords > complex_descriptors_size) {
int new_size = complex_descriptors_size * 2 + nwords;
- complex_descriptors = g_realloc (complex_descriptors, new_size * sizeof (gsize));
+ complex_descriptors = (gsize *)g_realloc (complex_descriptors, new_size * sizeof (gsize));
complex_descriptors_size = new_size;
}
SGEN_LOG (6, "Complex descriptor %d, size: %d (total desc memory: %d)", res, nwords, complex_descriptors_size);
if (numbits < 32 && all_ref_root_descrs [numbits])
return all_ref_root_descrs [numbits];
- gc_bitmap = g_malloc0 (ALIGN_TO (ALIGN_TO (numbits, 8) + 1, sizeof (gsize)));
+ gc_bitmap = (gsize *)g_malloc0 (ALIGN_TO (ALIGN_TO (numbits, 8) + 1, sizeof (gsize)));
memset (gc_bitmap, 0xff, num_bytes);
if (numbits < ((sizeof (*gc_bitmap) * 8) - ROOT_DESC_TYPE_SHIFT))
gc_bitmap[0] = GUINT64_TO_LE(gc_bitmap[0]);
if (no_finalize)
return;
- SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) {
+ SGEN_HASH_TABLE_FOREACH (hash_table, GCObject *, object, gpointer, dummy) {
int tag = tagged_object_get_tag (object);
object = tagged_object_get_object (object);
if (no_finalize)
return;
- SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) {
+ SGEN_HASH_TABLE_FOREACH (hash_table, GCObject *, object, gpointer, dummy) {
int tag = tagged_object_get_tag (object);
object = tagged_object_get_object (object);
if (!major_collector.is_object_live (object)) {
if (no_finalize || !out_size || !out_array)
return 0;
count = 0;
- SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) {
+ SGEN_HASH_TABLE_FOREACH (hash_table, GCObject *, object, gpointer, dummy) {
object = tagged_object_get_object (object);
if (predicate (object, user_data)) {
GCObject *object;
gpointer dummy G_GNUC_UNUSED;
- SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) {
+ SGEN_HASH_TABLE_FOREACH (hash_table, GCObject *, object, gpointer, dummy) {
object = tagged_object_get_object (object);
if (predicate (object, user_data)) {
GrayQueueSection *section = sgen_gray_object_dequeue_section (queue);
if (!section)
break;
- sgen_section_gray_queue_enqueue (queue->alloc_prepare_data, section);
+ sgen_section_gray_queue_enqueue ((SgenSectionGrayQueue *)queue->alloc_prepare_data, section);
wake = TRUE;
}
}
if (allow_flags) {
- if (!(obj = SGEN_OBJECT_IS_FORWARDED (start)))
+ if (!(obj = (char *)SGEN_OBJECT_IS_FORWARDED (start)))
obj = start;
} else {
obj = start;
* lock must be held. For serial collectors that is not necessary.
*/
void
-sgen_add_to_global_remset (gpointer ptr, gpointer obj)
+sgen_add_to_global_remset (gpointer ptr, GCObject *obj)
{
SGEN_ASSERT (5, sgen_ptr_in_nursery (obj), "Target pointer of global remset must be in the nursery");
RootRecord *root;
SGEN_LOG (2, "Scanning pinned roots (%d bytes, %d/%d entries)", (int)roots_size, roots_hash [ROOT_TYPE_NORMAL].num_entries, roots_hash [ROOT_TYPE_PINNED].num_entries);
/* objects pinned from the API are inside these roots */
- SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], start_root, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], void **, start_root, RootRecord *, root) {
SGEN_LOG (6, "Pinned roots %p-%p", start_root, root->end_root);
sgen_conservatively_pin_objects_from (start_root, (void**)root->end_root, start_nursery, end_nursery, PIN_TYPE_OTHER);
} SGEN_HASH_TABLE_FOREACH_END;
static void
single_arg_user_copy_or_mark (GCObject **obj, void *gc_data)
{
- ScanCopyContext *ctx = gc_data;
+ ScanCopyContext *ctx = (ScanCopyContext *)gc_data;
ctx->ops->copy_or_mark_object (obj, ctx->queue);
}
}
return;
case ROOT_DESC_COMPLEX: {
- gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
+ gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
gsize bwords = (*bitmap_data) - 1;
void **start_run = start_root;
bitmap_data++;
* objects in the existing nursery.
*/
/* FIXME: handle OOM */
- section = sgen_alloc_internal (INTERNAL_MEM_SECTION);
+ section = (GCMemSection *)sgen_alloc_internal (INTERNAL_MEM_SECTION);
alloc_size = sgen_nursery_size;
/* If there isn't enough space even for the nursery we should simply abort. */
g_assert (sgen_memgov_try_alloc_space (alloc_size, SPACE_NURSERY));
- data = major_collector.alloc_heap (alloc_size, alloc_size, DEFAULT_NURSERY_BITS);
+ data = (char *)major_collector.alloc_heap (alloc_size, alloc_size, DEFAULT_NURSERY_BITS);
sgen_update_heap_boundaries ((mword)data, (mword)(data + sgen_nursery_size));
SGEN_LOG (4, "Expanding nursery size (%p-%p): %lu, total: %lu", data, data + alloc_size, (unsigned long)sgen_nursery_size, (unsigned long)sgen_gc_get_total_heap_allocation ());
section->data = section->next_data = data;
section->size = alloc_size;
section->end_data = data + sgen_nursery_size;
scan_starts = (alloc_size + SCAN_START_SIZE - 1) / SCAN_START_SIZE;
- section->scan_starts = sgen_alloc_internal_dynamic (sizeof (char*) * scan_starts, INTERNAL_MEM_SCAN_STARTS, TRUE);
+ section->scan_starts = (char **)sgen_alloc_internal_dynamic (sizeof (char*) * scan_starts, INTERNAL_MEM_SCAN_STARTS, TRUE);
section->num_scan_start = scan_starts;
nursery_section = section;
size_t i;
for (i = 0; i < fin_queue->next_slot; ++i) {
- GCObject *obj = fin_queue->data [i];
+ GCObject *obj = (GCObject *)fin_queue->data [i];
if (!obj)
continue;
SGEN_LOG (5, "Scan of fin ready object: %p (%s)\n", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj)));
{
void **start_root;
RootRecord *root;
- SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
precisely_scan_objects_from (start_root, (void**)root->end_root, addr_start, addr_end, root->root_desc, ctx);
} SGEN_HASH_TABLE_FOREACH_END;
static void
job_remembered_set_scan (void *worker_data_untyped, SgenThreadPoolJob *job)
{
- WorkerData *worker_data = worker_data_untyped;
+ WorkerData *worker_data = (WorkerData *)worker_data_untyped;
ScanJob *job_data = (ScanJob*)job;
ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
remset.scan_remsets (ctx);
static void
job_scan_from_registered_roots (void *worker_data_untyped, SgenThreadPoolJob *job)
{
- WorkerData *worker_data = worker_data_untyped;
+ WorkerData *worker_data = (WorkerData *)worker_data_untyped;
ScanFromRegisteredRootsJob *job_data = (ScanFromRegisteredRootsJob*)job;
ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
static void
job_scan_thread_data (void *worker_data_untyped, SgenThreadPoolJob *job)
{
- WorkerData *worker_data = worker_data_untyped;
+ WorkerData *worker_data = (WorkerData *)worker_data_untyped;
ScanThreadDataJob *job_data = (ScanThreadDataJob*)job;
ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
static void
job_scan_finalizer_entries (void *worker_data_untyped, SgenThreadPoolJob *job)
{
- WorkerData *worker_data = worker_data_untyped;
+ WorkerData *worker_data = (WorkerData *)worker_data_untyped;
ScanFinalizerEntriesJob *job_data = (ScanFinalizerEntriesJob*)job;
ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
static void
job_scan_major_mod_union_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
{
- WorkerData *worker_data = worker_data_untyped;
+ WorkerData *worker_data = (WorkerData *)worker_data_untyped;
ScanJob *job_data = (ScanJob*)job;
ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
static void
job_scan_los_mod_union_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
{
- WorkerData *worker_data = worker_data_untyped;
+ WorkerData *worker_data = (WorkerData *)worker_data_untyped;
ScanJob *job_data = (ScanJob*)job;
ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
if (!sgen_pointer_queue_is_empty (&fin_ready_queue)) {
pending_unqueued_finalizer = TRUE;
mono_memory_write_barrier ();
- obj = sgen_pointer_queue_pop (&fin_ready_queue);
+ obj = (GCObject *)sgen_pointer_queue_pop (&fin_ready_queue);
} else if (!sgen_pointer_queue_is_empty (&critical_fin_queue)) {
pending_unqueued_finalizer = TRUE;
mono_memory_write_barrier ();
- obj = sgen_pointer_queue_pop (&critical_fin_queue);
+ obj = (GCObject *)sgen_pointer_queue_pop (&critical_fin_queue);
} else {
obj = NULL;
}
int i;
LOCK_GC;
for (i = 0; i < ROOT_TYPE_NUM; ++i) {
- RootRecord *root = sgen_hash_table_lookup (&roots_hash [i], start);
+ RootRecord *root = (RootRecord *)sgen_hash_table_lookup (&roots_hash [i], start);
/* we allow changing the size and the descriptor (for thread statics etc) */
if (root) {
size_t old_size = root->end_root - start;
SGEN_LOG (8, "Wbarrier atomic store at %p to %p (%s)", ptr, value, value ? sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (value)) : "null");
- InterlockedWritePointer (ptr, value);
+ InterlockedWritePointer ((volatile gpointer *)ptr, value);
if (ptr_in_nursery (value) || concurrent_collection_in_progress)
mono_gc_wbarrier_generic_nostore (ptr);
void
sgen_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
{
- GCObject **dest = _dest;
- GCObject **src = _src;
+ GCObject **dest = (GCObject **)_dest;
+ GCObject **src = (GCObject **)_src;
while (size) {
if (bitmap & 0x1)
#define SGEN_POINTER_UNTAG_VTABLE(p) SGEN_POINTER_UNTAG_ALL((p))
/* returns NULL if not forwarded, or the forwarded address */
-#define SGEN_VTABLE_IS_FORWARDED(vtable) (SGEN_POINTER_IS_TAGGED_FORWARDED ((vtable)) ? SGEN_POINTER_UNTAG_VTABLE ((vtable)) : NULL)
-#define SGEN_OBJECT_IS_FORWARDED(obj) (SGEN_VTABLE_IS_FORWARDED (((mword*)(obj))[0]))
+#define SGEN_VTABLE_IS_FORWARDED(vtable) ((GCVTable *)(SGEN_POINTER_IS_TAGGED_FORWARDED ((vtable)) ? SGEN_POINTER_UNTAG_VTABLE ((vtable)) : NULL))
+#define SGEN_OBJECT_IS_FORWARDED(obj) ((GCObject *)SGEN_VTABLE_IS_FORWARDED (((mword*)(obj))[0]))
#define SGEN_VTABLE_IS_PINNED(vtable) SGEN_POINTER_IS_TAGGED_PINNED ((vtable))
#define SGEN_OBJECT_IS_PINNED(obj) (SGEN_VTABLE_IS_PINNED (((mword*)(obj))[0]))
* Since we set bits in the vtable, use the macro to load it from the pointer to
* an object that is potentially pinned.
*/
-#define SGEN_LOAD_VTABLE(obj) ((GCVTable)(SGEN_POINTER_UNTAG_ALL (SGEN_LOAD_VTABLE_UNCHECKED ((obj)))))
+#define SGEN_LOAD_VTABLE(obj) ((GCVTable)(SGEN_POINTER_UNTAG_ALL (SGEN_LOAD_VTABLE_UNCHECKED ((GCObject *)(obj)))))
/*
List of what each bit on of the vtable gc bits means.
void sgen_pin_stats_print_class_stats (void);
void sgen_sort_addresses (void **array, size_t size);
-void sgen_add_to_global_remset (gpointer ptr, gpointer obj);
+void sgen_add_to_global_remset (gpointer ptr, GCObject *obj);
int sgen_get_current_collection_generation (void);
gboolean sgen_collection_is_concurrent (void);
protocol_gchandle_update (int handle_type, gpointer link, gpointer old_value, gpointer new_value)
{
gboolean old = MONO_GC_HANDLE_IS_OBJECT_POINTER (old_value);
- gboolean new = MONO_GC_HANDLE_IS_OBJECT_POINTER (new_value);
+ gboolean new_ = MONO_GC_HANDLE_IS_OBJECT_POINTER (new_value);
gboolean track = handle_type == HANDLE_WEAK_TRACK;
if (!MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type))
return;
- if (!old && new)
+ if (!old && new_)
binary_protocol_dislink_add (link, MONO_GC_REVEAL_POINTER (new_value, TRUE), track);
- else if (old && !new)
+ else if (old && !new_)
binary_protocol_dislink_remove (link, track);
- else if (old && new && old_value != new_value)
+ else if (old && new_ && old_value != new_value)
binary_protocol_dislink_update (link, MONO_GC_REVEAL_POINTER (new_value, TRUE), track);
}
static inline gpointer
try_set_slot (volatile gpointer *slot, GCObject *obj, gpointer old, GCHandleType type)
{
- gpointer new;
+ gpointer new_;
if (obj)
- new = MONO_GC_HANDLE_OBJECT_POINTER (obj, GC_HANDLE_TYPE_IS_WEAK (type));
+ new_ = MONO_GC_HANDLE_OBJECT_POINTER (obj, GC_HANDLE_TYPE_IS_WEAK (type));
else
- new = MONO_GC_HANDLE_METADATA_POINTER (sgen_client_default_metadata (), GC_HANDLE_TYPE_IS_WEAK (type));
- SGEN_ASSERT (0, new, "Why is the occupied bit not set?");
- if (InterlockedCompareExchangePointer (slot, new, old) == old) {
- protocol_gchandle_update (type, (gpointer)slot, old, new);
- return new;
+ new_ = MONO_GC_HANDLE_METADATA_POINTER (sgen_client_default_metadata (), GC_HANDLE_TYPE_IS_WEAK (type));
+ SGEN_ASSERT (0, new_, "Why is the occupied bit not set?");
+ if (InterlockedCompareExchangePointer (slot, new_, old) == old) {
+ protocol_gchandle_update (type, (gpointer)slot, old, new_);
+ return new_;
}
return NULL;
}
volatile gpointer *link_addr = &(handles->entries [bucket] [offset]);
if (MONO_GC_HANDLE_OCCUPIED (*link_addr))
return FALSE;
- return try_set_slot (link_addr, obj, NULL, handles->type) != NULL;
+ return try_set_slot (link_addr, obj, NULL, (GCHandleType)handles->type) != NULL;
}
static HandleData gc_handles [] = {
const size_t new_bucket_size = sizeof (**handles->entries) * growth;
if (handles->capacity >= new_capacity)
return;
- entries = g_malloc0 (new_bucket_size);
+ entries = (gpointer *)g_malloc0 (new_bucket_size);
if (handles->type == HANDLE_PINNED)
sgen_register_root ((char *)entries, new_bucket_size, SGEN_DESCRIPTOR_NULL, ROOT_TYPE_PINNED, MONO_ROOT_SOURCE_GC_HANDLE, "pinned gc handles");
/* The zeroing of the newly allocated bucket must be complete before storing
mono_gchandle_get_target (guint32 gchandle)
{
guint index = MONO_GC_HANDLE_SLOT (gchandle);
- guint type = MONO_GC_HANDLE_TYPE (gchandle);
+ GCHandleType type = MONO_GC_HANDLE_TYPE (gchandle);
HandleData *handles = gc_handles_for_type (type);
/* Invalid handles are possible; accessing one should produce NULL. (#34276) */
if (!handles)
sgen_gchandle_set_target (guint32 gchandle, GCObject *obj)
{
guint index = MONO_GC_HANDLE_SLOT (gchandle);
- guint type = MONO_GC_HANDLE_TYPE (gchandle);
+ GCHandleType type = MONO_GC_HANDLE_TYPE (gchandle);
HandleData *handles = gc_handles_for_type (type);
if (!handles)
return;
do {
slot = handles->entries [bucket] [offset];
SGEN_ASSERT (0, MONO_GC_HANDLE_OCCUPIED (slot), "Why are we setting the target on an unoccupied slot?");
- } while (!try_set_slot (&handles->entries [bucket] [offset], obj, slot, handles->type));
+ } while (!try_set_slot (&handles->entries [bucket] [offset], obj, slot, (GCHandleType)handles->type));
}
static gpointer
if (!MONO_GC_HANDLE_OCCUPIED (slot))
return NULL;
if (MONO_GC_HANDLE_IS_OBJECT_POINTER (slot)) {
- GCObject *obj = MONO_GC_REVEAL_POINTER (slot, is_weak);
+ GCObject *obj = (GCObject *)MONO_GC_REVEAL_POINTER (slot, is_weak);
/* See note [dummy use]. */
sgen_dummy_use (obj);
/*
sgen_gchandle_get_metadata (guint32 gchandle)
{
guint index = MONO_GC_HANDLE_SLOT (gchandle);
- guint type = MONO_GC_HANDLE_TYPE (gchandle);
+ GCHandleType type = MONO_GC_HANDLE_TYPE (gchandle);
HandleData *handles = gc_handles_for_type (type);
if (!handles)
return NULL;
mono_gchandle_free (guint32 gchandle)
{
guint index = MONO_GC_HANDLE_SLOT (gchandle);
- guint type = MONO_GC_HANDLE_TYPE (gchandle);
+ GCHandleType type = MONO_GC_HANDLE_TYPE (gchandle);
HandleData *handles = gc_handles_for_type (type);
if (!handles)
return;
if (!MONO_GC_HANDLE_VALID (hidden))
return hidden;
- obj = MONO_GC_REVEAL_POINTER (hidden, MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type));
+ obj = (GCObject *)MONO_GC_REVEAL_POINTER (hidden, MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type));
SGEN_ASSERT (0, obj, "Why is the hidden pointer NULL?");
if (object_older_than (obj, max_generation))
if (!MONO_GC_HANDLE_VALID (hidden))
return hidden;
- obj = MONO_GC_REVEAL_POINTER (hidden, MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type));
+ obj = (GCObject *)MONO_GC_REVEAL_POINTER (hidden, MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type));
SGEN_ASSERT (0, obj, "Why is the hidden pointer NULL?");
if (object_older_than (obj, max_generation))
STATE_TRANSITION (section, GRAY_QUEUE_SECTION_STATE_FREE_LIST, GRAY_QUEUE_SECTION_STATE_FLOATING);
} else {
/* Allocate a new section */
- section = sgen_alloc_internal (INTERNAL_MEM_GRAY_QUEUE);
+ section = (GrayQueueSection *)sgen_alloc_internal (INTERNAL_MEM_GRAY_QUEUE);
STATE_SET (section, GRAY_QUEUE_SECTION_STATE_FLOATING);
}
new_size = g_spaced_primes_closest (hash_table->num_entries);
}
- new_hash = sgen_alloc_internal_dynamic (new_size * sizeof (SgenHashTableEntry*), hash_table->table_mem_type, TRUE);
+ new_hash = (SgenHashTableEntry **)sgen_alloc_internal_dynamic (new_size * sizeof (SgenHashTableEntry*), hash_table->table_mem_type, TRUE);
for (i = 0; i < old_hash_size; ++i) {
for (entry = old_hash [i]; entry; entry = next) {
hash = hash_table->hash_func (entry->key) % new_size;
return FALSE;
}
- entry = sgen_alloc_internal (hash_table->entry_mem_type);
+ entry = (SgenHashTableEntry *)sgen_alloc_internal (hash_table->entry_mem_type);
entry->key = key;
memcpy (entry->data, new_value, hash_table->data_size);
#define sgen_hash_table_num_entries(h) ((h)->num_entries)
-#define sgen_hash_table_key_for_value_pointer(v) (((SgenHashTableEntry*)((char*)(v) - G_STRUCT_OFFSET (SgenHashTableEntry, data)))->key)
+#define sgen_hash_table_key_for_value_pointer(v) ((GCObject *)(((SgenHashTableEntry*)((char*)(v) - G_STRUCT_OFFSET (SgenHashTableEntry, data)))->key))
-#define SGEN_HASH_TABLE_FOREACH(h,k,v) do { \
+#define SGEN_HASH_TABLE_FOREACH(h,tk,k,tv,v) do { \
SgenHashTable *__hash_table = (h); \
SgenHashTableEntry **__table = __hash_table->table; \
guint __i; \
for (__iter = &__table [__i]; *__iter; __iter = __next) { \
SgenHashTableEntry *__entry = *__iter; \
__next = &__entry->next; \
- (k) = __entry->key; \
- (v) = (gpointer)__entry->data;
+ (k) = (tk)__entry->key; \
+ (v) = (tv)__entry->data;
/* The loop must be continue'd after using this! */
#define SGEN_HASH_TABLE_FOREACH_REMOVE(free) do { \
void *p;
if (size > allocator_sizes [NUM_ALLOCATORS - 1]) {
- p = sgen_alloc_os_memory (size, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, NULL);
+ p = sgen_alloc_os_memory (size, (SgenAllocFlags)(SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE), NULL);
if (!p)
sgen_assert_memory_alloc (NULL, size, description_for_type (type));
} else {
if (!sgen_memgov_try_alloc_space (LOS_SECTION_SIZE, SPACE_LOS))
return NULL;
- section = sgen_alloc_os_memory_aligned (LOS_SECTION_SIZE, LOS_SECTION_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, NULL);
+ section = (LOSSection *)sgen_alloc_os_memory_aligned (LOS_SECTION_SIZE, LOS_SECTION_SIZE, (SgenAllocFlags)(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE), NULL);
if (!section)
return NULL;
alloc_size += pagesize - 1;
alloc_size &= ~(pagesize - 1);
if (sgen_memgov_try_alloc_space (alloc_size, SPACE_LOS)) {
- obj = sgen_alloc_os_memory (alloc_size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, NULL);
+ obj = (LOSObject *)sgen_alloc_os_memory (alloc_size, (SgenAllocFlags)(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE), NULL);
}
} else {
obj = get_los_section_memory (size + sizeof (LOSObject));
if (mod_union)
return mod_union;
mod_union = sgen_card_table_alloc_mod_union ((char*)obj->data, size);
- other = SGEN_CAS_PTR ((gpointer*)&obj->cardtable_mod_union, mod_union, NULL);
+ other = (guint8 *)SGEN_CAS_PTR ((gpointer*)&obj->cardtable_mod_union, mod_union, NULL);
if (!other) {
SGEN_ASSERT (0, obj->cardtable_mod_union == mod_union, "Why did CAS not replace?");
return mod_union;
HEAVY_STAT (++stat_optimized_copy_nursery_pinned);
return TRUE;
}
- if ((forwarded = SGEN_VTABLE_IS_FORWARDED (vtable_word))) {
+ if ((forwarded = (GCObject *)SGEN_VTABLE_IS_FORWARDED (vtable_word))) {
HEAVY_STAT (++stat_optimized_copy_nursery_forwarded);
SGEN_UPDATE_REFERENCE (ptr, forwarded);
return sgen_ptr_in_nursery (forwarded);
#ifdef COPY_OR_MARK_WITH_EVACUATION
{
GCObject *forwarded;
- if ((forwarded = SGEN_VTABLE_IS_FORWARDED (vtable_word))) {
+ if ((forwarded = (GCObject *)SGEN_VTABLE_IS_FORWARDED (vtable_word))) {
HEAVY_STAT (++stat_optimized_copy_major_forwarded);
SGEN_UPDATE_REFERENCE (ptr, forwarded);
SGEN_ASSERT (9, !sgen_ptr_in_nursery (forwarded), "Cannot be forwarded to nursery.");
} while (0)
#else
#define HANDLE_PTR(ptr,obj) do { \
- void *__old = *(ptr); \
+ GCObject *__old = *(ptr); \
binary_protocol_scan_process_reference ((full_object), (ptr), __old); \
if (__old) { \
gboolean __still_in_nursery = COPY_OR_MARK_FUNCTION_NAME ((ptr), __old, queue); \
if (G_UNLIKELY (__still_in_nursery && !sgen_ptr_in_nursery ((ptr)) && !SGEN_OBJECT_IS_CEMENTED (*(ptr)))) { \
- void *__copy = *(ptr); \
+ GCObject *__copy = *(ptr); \
sgen_add_to_global_remset ((ptr), __copy); \
} \
} \
#undef HANDLE_PTR
#define HANDLE_PTR(ptr,obj) do { \
- void *__old = *(ptr); \
+ GCObject *__old = *(ptr); \
binary_protocol_scan_process_reference ((full_object), (ptr), __old); \
if (__old) { \
gboolean __still_in_nursery = major_copy_or_mark_object_with_evacuation ((ptr), __old, queue); \
if (G_UNLIKELY (__still_in_nursery && !sgen_ptr_in_nursery ((ptr)) && !SGEN_OBJECT_IS_CEMENTED (*(ptr)))) { \
- void *__copy = *(ptr); \
+ GCObject *__copy = *(ptr); \
sgen_add_to_global_remset ((ptr), __copy); \
} \
} \
#define MS_BLOCK_FOR_BLOCK_INFO(b) ((char*)(b))
-#define MS_BLOCK_OBJ(b,i) ((void*)(MS_BLOCK_FOR_BLOCK_INFO(b) + MS_BLOCK_SKIP + (b)->obj_size * (i)))
+#define MS_BLOCK_OBJ(b,i) ((GCObject *)(MS_BLOCK_FOR_BLOCK_INFO(b) + MS_BLOCK_SKIP + (b)->obj_size * (i)))
#define MS_BLOCK_OBJ_FOR_SIZE(b,i,obj_size) (MS_BLOCK_FOR_BLOCK_INFO(b) + MS_BLOCK_SKIP + (obj_size) * (i))
#define MS_BLOCK_DATA_FOR_OBJ(o) ((char*)((mword)(o) & ~(mword)(MS_BLOCK_SIZE - 1)))
#define BLOCK_IS_TAGGED_CHECKING(bl) SGEN_POINTER_IS_TAGGED_2 ((bl))
#define BLOCK_TAG_CHECKING(bl) SGEN_POINTER_TAG_2 ((bl))
-#define BLOCK_UNTAG(bl) SGEN_POINTER_UNTAG_12 ((bl))
+#define BLOCK_UNTAG(bl) ((MSBlockInfo *)SGEN_POINTER_UNTAG_12 ((bl)))
#define BLOCK_TAG(bl) ((bl)->has_references ? BLOCK_TAG_HAS_REFERENCES ((bl)) : (bl))
size_t __index; \
SGEN_ASSERT (0, sgen_is_world_stopped () && !sweep_in_progress (), "Can't iterate blocks while the world is running or sweep is in progress."); \
for (__index = 0; __index < allocated_blocks.next_slot; ++__index) { \
- (bl) = allocated_blocks.data [__index]; \
+ (bl) = (MSBlockInfo *)allocated_blocks.data [__index]; \
(hr) = BLOCK_IS_TAGGED_HAS_REFERENCES ((bl)); \
(bl) = BLOCK_UNTAG ((bl));
#define END_FOREACH_BLOCK_NO_LOCK } }
{
char *start;
if (nursery_align)
- start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "nursery");
+ start = (char *)sgen_alloc_os_memory_aligned (nursery_size, nursery_align, (SgenAllocFlags)(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE), "nursery");
else
- start = sgen_alloc_os_memory (nursery_size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "nursery");
+ start = (char *)sgen_alloc_os_memory (nursery_size, (SgenAllocFlags)(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE), "nursery");
return start;
}
*/
int alloc_num = MS_BLOCK_ALLOC_NUM;
for (;;) {
- p = sgen_alloc_os_memory_aligned (MS_BLOCK_SIZE * alloc_num, MS_BLOCK_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE,
- alloc_num == 1 ? "major heap section" : NULL);
+ p = (char *)sgen_alloc_os_memory_aligned (MS_BLOCK_SIZE * alloc_num, MS_BLOCK_SIZE,
+ (SgenAllocFlags)(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE),
+ alloc_num == 1 ? "major heap section" : NULL);
if (p)
break;
alloc_num >>= 1;
MSBlockInfo *old;
do {
block->next_free = old = free_blocks [size_index];
- } while (SGEN_CAS_PTR ((gpointer)&free_blocks [size_index], block, old) != old);
+ } while (SGEN_CAS_PTR ((volatile gpointer *)&free_blocks [size_index], block, old) != old);
}
static void major_finish_sweep_checking (void);
next_free_slot = *(void**)obj;
if (next_free_slot) {
- block->free_list = next_free_slot;
+ block->free_list = (gpointer *)next_free_slot;
return obj;
}
next_free_block = block->next_free;
- if (SGEN_CAS_PTR ((gpointer)&free_blocks [size_index], next_free_block, block) != block)
+ if (SGEN_CAS_PTR ((volatile gpointer *)&free_blocks [size_index], next_free_block, block) != block)
goto retry;
block->free_list = NULL;
/* FIXME: assumes object layout */
*(GCVTable*)obj = vtable;
- return obj;
+ return (GCObject *)obj;
}
static GCObject*
sgen_perform_collection (0, GENERATION_OLD, "pinned alloc failure", TRUE);
res = alloc_obj (vtable, size, TRUE, has_references);
}
- return res;
+ return (GCObject *)res;
}
static void
*start = NULL;
for (i = 0; i <= count; ++i) {
if (ptr >= (char*)MS_BLOCK_OBJ (block, i) && ptr < (char*)MS_BLOCK_OBJ (block, i + 1)) {
- *start = MS_BLOCK_OBJ (block, i);
+ *start = (char *)MS_BLOCK_OBJ (block, i);
break;
}
}
}
static gboolean
-try_set_sweep_state (int new, int expected)
+try_set_sweep_state (int new_, int expected)
{
- int old = SGEN_CAS (&sweep_state, new, expected);
+ int old = SGEN_CAS (&sweep_state, new_, expected);
return old == expected;
}
static void
-set_sweep_state (int new, int expected)
+set_sweep_state (int new_, int expected)
{
- gboolean success = try_set_sweep_state (new, expected);
+ gboolean success = try_set_sweep_state (new_, expected);
SGEN_ASSERT (0, success, "Could not set sweep state.");
}
major_dump_heap (FILE *heap_dump_file)
{
MSBlockInfo *block;
- int *slots_available = alloca (sizeof (int) * num_block_obj_sizes);
- int *slots_used = alloca (sizeof (int) * num_block_obj_sizes);
+ int *slots_available = (int *)alloca (sizeof (int) * num_block_obj_sizes);
+ int *slots_used = (int *)alloca (sizeof (int) * num_block_obj_sizes);
int i;
for (i = 0; i < num_block_obj_sizes; ++i)
start = i;
} else {
if (start >= 0) {
- sgen_dump_occupied (MS_BLOCK_OBJ (block, start), MS_BLOCK_OBJ (block, i), MS_BLOCK_FOR_BLOCK_INFO (block));
+ sgen_dump_occupied ((char *)MS_BLOCK_OBJ (block, start), (char *)MS_BLOCK_OBJ (block, i), MS_BLOCK_FOR_BLOCK_INFO (block));
start = -1;
}
}
else if (!allocate)
return NULL;
mod_union = sgen_card_table_alloc_mod_union (MS_BLOCK_FOR_BLOCK_INFO (block), MS_BLOCK_SIZE);
- other = SGEN_CAS_PTR ((gpointer*)&block->cardtable_mod_union, mod_union, NULL);
+ other = (guint8 *)SGEN_CAS_PTR ((gpointer*)&block->cardtable_mod_union, mod_union, NULL);
if (!other) {
SGEN_ASSERT (0, block->cardtable_mod_union == mod_union, "Why did CAS not replace?");
return mod_union;
memset (obj, 0, obj_size);
}
*(void**)obj = block->free_list;
- block->free_list = obj;
+ block->free_list = (void **)obj;
}
}
}
void *next = *(void**)block->free_list;
*(void**)block->free_list = reversed;
reversed = block->free_list;
- block->free_list = next;
+ block->free_list = (void **)next;
}
- block->free_list = reversed;
+ block->free_list = (void **)reversed;
mono_memory_write_barrier ();
sgen_register_fixed_internal_mem_type (INTERNAL_MEM_MS_BLOCK_INFO, sizeof (MSBlockInfo));
num_block_obj_sizes = ms_calculate_block_obj_sizes (MS_BLOCK_OBJ_SIZE_FACTOR, NULL);
- block_obj_sizes = sgen_alloc_internal_dynamic (sizeof (int) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
+ block_obj_sizes = (int *)sgen_alloc_internal_dynamic (sizeof (int) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
ms_calculate_block_obj_sizes (MS_BLOCK_OBJ_SIZE_FACTOR, block_obj_sizes);
- evacuate_block_obj_sizes = sgen_alloc_internal_dynamic (sizeof (gboolean) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
+ evacuate_block_obj_sizes = (gboolean *)sgen_alloc_internal_dynamic (sizeof (gboolean) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
for (i = 0; i < num_block_obj_sizes; ++i)
evacuate_block_obj_sizes [i] = FALSE;
- sweep_slots_available = sgen_alloc_internal_dynamic (sizeof (size_t) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
- sweep_slots_used = sgen_alloc_internal_dynamic (sizeof (size_t) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
- sweep_num_blocks = sgen_alloc_internal_dynamic (sizeof (size_t) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
+ sweep_slots_available = (size_t *)sgen_alloc_internal_dynamic (sizeof (size_t) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
+ sweep_slots_used = (size_t *)sgen_alloc_internal_dynamic (sizeof (size_t) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
+ sweep_num_blocks = (size_t *)sgen_alloc_internal_dynamic (sizeof (size_t) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
/*
{
*/
for (i = 0; i < MS_BLOCK_TYPE_MAX; ++i)
- free_block_lists [i] = sgen_alloc_internal_dynamic (sizeof (MSBlockInfo*) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
+ free_block_lists [i] = (MSBlockInfo *volatile *)sgen_alloc_internal_dynamic (sizeof (MSBlockInfo*) * num_block_obj_sizes, INTERNAL_MEM_MS_TABLES, TRUE);
for (i = 0; i < MS_NUM_FAST_BLOCK_OBJ_SIZE_INDEXES; ++i)
fast_block_obj_size_indexes [i] = ms_find_block_obj_size_index (i * 8);
frag->next = frag->next_in_order = NULL;
return frag;
}
- frag = sgen_alloc_internal (INTERNAL_MEM_FRAGMENT);
+ frag = (SgenFragment *)sgen_alloc_internal (INTERNAL_MEM_FRAGMENT);
frag->next = frag->next_in_order = NULL;
return frag;
}
fragment->fragment_start = start;
fragment->fragment_next = start;
fragment->fragment_end = end;
- fragment->next_in_order = fragment->next = unmask (allocator->region_head);
+ fragment->next_in_order = fragment->next = (SgenFragment *)unmask (allocator->region_head);
allocator->region_head = allocator->alloc_head = fragment;
g_assert (fragment->fragment_end > fragment->fragment_start);
printf ("retry count for fppf is %d\n", count);
#endif
- cur = unmask (*prev);
+ cur = (SgenFragment *)unmask (*prev);
while (1) {
if (cur == NULL)
return prev;
prev = &cur->next;
} else {
- next = unmask (next);
+ next = (SgenFragment *)unmask (next);
if (InterlockedCompareExchangePointer ((volatile gpointer*)prev, next, cur) != cur)
goto try_again;
/*we must make sure that the next from cur->next happens after*/
mono_memory_write_barrier ();
}
- cur = unmask (next);
+ cur = (SgenFragment *)unmask (next);
}
return NULL;
}
#endif
restart:
- for (frag = unmask (allocator->alloc_head); unmask (frag); frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (allocator->alloc_head); unmask (frag); frag = (SgenFragment *)unmask (frag->next)) {
HEAVY_STAT (++stat_alloc_iterations);
if (size <= (size_t)(frag->fragment_end - frag->fragment_next)) {
previous = &allocator->alloc_head;
for (frag = *previous; frag; frag = *previous) {
- char *p = serial_alloc_from_fragment (previous, frag, size);
+ char *p = (char *)serial_alloc_from_fragment (previous, frag, size);
HEAVY_STAT (++stat_alloc_iterations);
InterlockedIncrement (&alloc_count);
#endif
- for (frag = unmask (allocator->alloc_head); frag; frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (allocator->alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
size_t frag_size = frag->fragment_end - frag->fragment_next;
HEAVY_STAT (++stat_alloc_range_iterations);
{
SgenFragment *frag;
- for (frag = unmask (allocator->alloc_head); frag; frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (allocator->alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
SGEN_LOG (4, "Clear nursery frag %p-%p", frag->fragment_next, frag->fragment_end);
sgen_clear_range (frag->fragment_next, frag->fragment_end);
#ifdef NALLOC_DEBUG
addr0 = addr1 = sgen_nursery_end;
if (pin_entry < pin_end)
- addr0 = *pin_entry;
+ addr0 = (char *)*pin_entry;
if (frags_ranges)
addr1 = frags_ranges->fragment_start;
if (!unmask (mutator_allocator.alloc_head)) {
SGEN_LOG (1, "Nursery fully pinned");
for (pin_entry = pin_start; pin_entry < pin_end; ++pin_entry) {
- void *p = *pin_entry;
+ GCObject *p = (GCObject *)*pin_entry;
SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
}
}
size = SGEN_ALIGN_UP (size);
- for (frag = unmask (mutator_allocator.alloc_head); frag; frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (mutator_allocator.alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
if ((size_t)(frag->fragment_end - frag->fragment_next) >= size)
return TRUE;
}
* since the nursery size must be a power of 2.
*/
sgen_space_bitmap_size = (end - start + SGEN_TO_SPACE_GRANULE_IN_BYTES * 8 - 1) / (SGEN_TO_SPACE_GRANULE_IN_BYTES * 8);
- sgen_space_bitmap = g_malloc0 (sgen_space_bitmap_size);
+ sgen_space_bitmap = (char *)g_malloc0 (sgen_space_bitmap_size);
/* Setup the single first large fragment */
sgen_minor_collector.init_nursery (&mutator_allocator, start, end);
node_ptr = &node->right;
}
- node = sgen_alloc_internal_dynamic (sizeof (PinStatAddress), INTERNAL_MEM_STATISTICS, TRUE);
+ node = (PinStatAddress *)sgen_alloc_internal_dynamic (sizeof (PinStatAddress), INTERNAL_MEM_STATISTICS, TRUE);
node->addr = addr;
node->pin_types = pin_type_bit;
node->left = node->right = NULL;
int i;
memset (&empty_entry, 0, sizeof (PinnedClassEntry));
- entry = lookup_vtable_entry (&pinned_class_hash_table, vtable, &empty_entry);
+ entry = (PinnedClassEntry *)lookup_vtable_entry (&pinned_class_hash_table, vtable, &empty_entry);
for (i = 0; i < PIN_TYPE_MAX; ++i) {
if (pin_types & (1 << i))
return;
memset (&empty_entry, 0, sizeof (GlobalRemsetClassEntry));
- entry = lookup_vtable_entry (&global_remset_class_hash_table, SGEN_LOAD_VTABLE (obj), &empty_entry);
+ entry = (GlobalRemsetClassEntry *)lookup_vtable_entry (&global_remset_class_hash_table, SGEN_LOAD_VTABLE (obj), &empty_entry);
++entry->num_remsets;
}
return;
mono_gc_printf (gc_debug_file, "\n%-50s %10s %10s %10s\n", "Class", "Stack", "Static", "Other");
- SGEN_HASH_TABLE_FOREACH (&pinned_class_hash_table, name, pinned_entry) {
+ SGEN_HASH_TABLE_FOREACH (&pinned_class_hash_table, char *, name, PinnedClassEntry *, pinned_entry) {
int i;
mono_gc_printf (gc_debug_file, "%-50s", name);
for (i = 0; i < PIN_TYPE_MAX; ++i)
} SGEN_HASH_TABLE_FOREACH_END;
mono_gc_printf (gc_debug_file, "\n%-50s %10s\n", "Class", "#Remsets");
- SGEN_HASH_TABLE_FOREACH (&global_remset_class_hash_table, name, remset_entry) {
+ SGEN_HASH_TABLE_FOREACH (&global_remset_class_hash_table, char *, name, GlobalRemsetClassEntry *, remset_entry) {
mono_gc_printf (gc_debug_file, "%-50s %10ld\n", name, remset_entry->num_remsets);
} SGEN_HASH_TABLE_FOREACH_END;
int i;
for (i = 0; i < last_num_pinned; ++i) {
- void *ptr = pin_queue.data [i];
+ GCObject *ptr = (GCObject *)pin_queue.data [i];
SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (ptr)), sgen_safe_object_get_size (ptr));
}
}
realloc_queue (SgenPointerQueue *queue)
{
size_t new_size = queue->size ? queue->size + queue->size/2 : 1024;
- void **new_data = sgen_alloc_internal_dynamic (sizeof (void*) * new_size, queue->mem_type, TRUE);
+ void **new_data = (void **)sgen_alloc_internal_dynamic (sizeof (void*) * new_size, queue->mem_type, TRUE);
memcpy (new_data, queue->data, sizeof (void*) * queue->next_slot);
sgen_free_internal_dynamic (queue->data, sizeof (void*) * queue->size, queue->mem_type);
IS_VTABLE_MATCH (FALSE)
END_PROTOCOL_ENTRY_HEAVY
-BEGIN_PROTOCOL_ENTRY_HEAVY4 (binary_protocol_block_set_state, TYPE_POINTER, addr, TYPE_SIZE, size, TYPE_INT, old, TYPE_INT, new)
+BEGIN_PROTOCOL_ENTRY_HEAVY4 (binary_protocol_block_set_state, TYPE_POINTER, addr, TYPE_SIZE, size, TYPE_INT, old, TYPE_INT, new_)
DEFAULT_PRINT ()
IS_ALWAYS_MATCH (FALSE)
MATCH_INDEX (matches_interval (ptr, entry->addr, entry->size) ? 0 : BINARY_PROTOCOL_NO_MATCH)
SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
- filename = sgen_alloc_internal_dynamic (strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
+ filename = (char *)sgen_alloc_internal_dynamic (strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
sprintf (filename, "%s.%d", filename_or_prefix, index);
return filename;
binary_protocol_init (const char *filename, long long limit)
{
#ifdef HAVE_UNISTD_H
- filename_or_prefix = sgen_alloc_internal_dynamic (strlen (filename) + 1, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
+ filename_or_prefix = (char *)sgen_alloc_internal_dynamic (strlen (filename) + 1, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
strcpy (filename_or_prefix, filename);
file_size_limit = limit;
for (buf = binary_protocol_buffers; buf != NULL; buf = buf->next)
++num_buffers;
- bufs = sgen_alloc_internal_dynamic (num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
+ bufs = (BinaryProtocolBuffer **)sgen_alloc_internal_dynamic (num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
for (buf = binary_protocol_buffers, i = 0; buf != NULL; buf = buf->next, i++)
bufs [i] = buf;
SGEN_ASSERT (0, i == num_buffers, "Binary protocol buffer count error");
if (buffer && buffer->index + length <= BINARY_PROTOCOL_BUFFER_SIZE)
return buffer;
- new_buffer = sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging memory");
+ new_buffer = (BinaryProtocolBuffer *)sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), (SgenAllocFlags)(SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE), "debugging memory");
new_buffer->next = buffer;
new_buffer->index = 0;
static void
mark_bits_in_range (char *space_bitmap, char *start, char *end)
{
- start = align_down (start, SGEN_TO_SPACE_GRANULE_BITS);
- end = align_up (end, SGEN_TO_SPACE_GRANULE_BITS);
+ start = (char *)align_down (start, SGEN_TO_SPACE_GRANULE_BITS);
+ end = (char *)align_up (end, SGEN_TO_SPACE_GRANULE_BITS);
for (;start < end; start += SGEN_TO_SPACE_GRANULE_IN_BYTES)
mark_bit (space_bitmap, start);
size_t allocated_size;
size_t aligned_objsize = (size_t)align_up (objsize, SGEN_TO_SPACE_GRANULE_BITS);
- p = sgen_fragment_allocator_serial_range_alloc (
+ p = (char *)sgen_fragment_allocator_serial_range_alloc (
&collector_allocator,
MAX (aligned_objsize, AGE_ALLOC_BUFFER_DESIRED_SIZE),
MAX (aligned_objsize, AGE_ALLOC_BUFFER_MIN_SIZE),
previous = &collector_allocator.alloc_head;
for (frag = *previous; frag; frag = *previous) {
- char *start = align_up (frag->fragment_next, SGEN_TO_SPACE_GRANULE_BITS);
- char *end = align_down (frag->fragment_end, SGEN_TO_SPACE_GRANULE_BITS);
+ char *start = (char *)align_up (frag->fragment_next, SGEN_TO_SPACE_GRANULE_BITS);
+ char *end = (char *)align_down (frag->fragment_end, SGEN_TO_SPACE_GRANULE_BITS);
/* Fragment is too small to be usable. */
if ((end - start) < SGEN_MAX_NURSERY_WASTE) {
init_nursery (SgenFragmentAllocator *allocator, char *start, char *end)
{
int alloc_quote = (int)((end - start) * alloc_ratio);
- promotion_barrier = align_down (start + alloc_quote, 3);
+ promotion_barrier = (char *)align_down (start + alloc_quote, 3);
sgen_fragment_allocator_add (allocator, start, promotion_barrier);
sgen_fragment_allocator_add (&collector_allocator, promotion_barrier, end);
region_age_size = (end - start) >> SGEN_TO_SPACE_GRANULE_BITS;
- region_age = g_malloc0 (region_age_size);
+ region_age = (char *)g_malloc0 (region_age_size);
}
static gboolean
get_job_and_set_in_progress (void)
{
for (size_t i = 0; i < job_queue.next_slot; ++i) {
- SgenThreadPoolJob *job = job_queue.data [i];
+ SgenThreadPoolJob *job = (SgenThreadPoolJob *)job_queue.data [i];
if (job->state == STATE_WAITING) {
job->state = STATE_IN_PROGRESS;
return job;
SgenThreadPoolJob*
sgen_thread_pool_job_alloc (const char *name, SgenThreadPoolJobFunc func, size_t size)
{
- SgenThreadPoolJob *job = sgen_alloc_internal_dynamic (size, INTERNAL_MEM_THREAD_POOL_JOB, TRUE);
+ SgenThreadPoolJob *job = (SgenThreadPoolJob *)sgen_alloc_internal_dynamic (size, INTERNAL_MEM_THREAD_POOL_JOB, TRUE);
job->name = name;
job->size = size;
job->state = STATE_WAITING;
static void
thread_pool_init_func (void *data_untyped)
{
- WorkerData *data = data_untyped;
+ WorkerData *data = (WorkerData *)data_untyped;
SgenMajorCollector *major = sgen_get_major_collector ();
sgen_client_thread_register_worker ();
static void
marker_idle_func (void *data_untyped)
{
- WorkerData *data = data_untyped;
+ WorkerData *data = (WorkerData *)data_untyped;
SGEN_ASSERT (0, continue_idle_func (), "Why are we called when we're not supposed to work?");
SGEN_ASSERT (0, sgen_concurrent_collection_in_progress (), "The worker should only mark in concurrent collections.");
sgen_workers_init (int num_workers)
{
int i;
- void **workers_data_ptrs = alloca(num_workers * sizeof(void *));
+ void **workers_data_ptrs = (void **)alloca(num_workers * sizeof(void *));
if (!sgen_get_major_collector ()->is_concurrent) {
sgen_thread_pool_init (num_workers, thread_pool_init_func, NULL, NULL, NULL);
workers_num = num_workers;
- workers_data = sgen_alloc_internal_dynamic (sizeof (WorkerData) * num_workers, INTERNAL_MEM_WORKER_DATA, TRUE);
+ workers_data = (WorkerData *)sgen_alloc_internal_dynamic (sizeof (WorkerData) * num_workers, INTERNAL_MEM_WORKER_DATA, TRUE);
memset (workers_data, 0, sizeof (WorkerData) * num_workers);
init_distribute_gray_queue ();
int slen = strlen (str);
gunichar2* temp;
/* allocate len + 1 utf16 characters plus 4 byte integer for length*/
- ret = g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
+ ret = (gchar *)g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
if (ret == NULL)
return NULL;
temp = g_utf8_to_utf16 (str, -1, NULL, NULL, NULL);
int i = 0;
unsigned short *res;
- res = marshal_alloc (2 * (length + 1));
+ res = (unsigned short *)marshal_alloc (2 * (length + 1));
// printf("test_lpwstr_marshal()\n");
const char abc[] = "ABC";
glong len = strlen(abc);
- *chars = marshal_alloc (2 * (len + 1));
+ *chars = (unsigned short *)marshal_alloc (2 * (len + 1));
while ( i < len ) {
(*chars) [i] = abc[i];
int i, len;
len = 4;
- arr = marshal_alloc (sizeof (gint32) * len);
+ arr = (gint32 *)marshal_alloc (sizeof (gint32) * len);
for (i = 0; i < len; ++i)
arr [i] = i;
*out_arr = arr;
mono_test_marshal_out_struct (int a, simplestruct *ss, int b, OutVTypeDelegate func)
{
/* Check that the input pointer is ignored */
- ss->d = (gpointer)0x12345678;
+ ss->d = (const char *)0x12345678;
func (a, ss, b);
simplestruct *ptr;
/* Check that the input pointer is ignored */
- ptr = (gpointer)0x12345678;
+ ptr = (simplestruct *)0x12345678;
res = delegate (&ptr);
if (res != 0)
LIBTEST_API int STDCALL
mono_test_marshal_delegate9 (SimpleDelegate9 delegate, gpointer ftn)
{
- return delegate (ftn);
+ return delegate ((int (*)(int))ftn);
}
static int STDCALL
const char m[] = "This is my message. Isn't it nice?";
char *str;
- str = marshal_alloc (strlen (m) + 1);
+ str = (char *)marshal_alloc (strlen (m) + 1);
memcpy (str, m, strlen (m) + 1);
*s = str;
s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
len = (len * 2) + 2;
- *s = marshal_alloc (len);
+ *s = (gunichar2 *)marshal_alloc (len);
memcpy (*s, s2, len);
g_free (s2);
if (strcmp (*s, "ABC"))
return 1;
- str = marshal_alloc (strlen (m) + 1);
+ str = (char *)marshal_alloc (strlen (m) + 1);
memcpy (str, m, strlen (m) + 1);
*s = str;
return 0;
}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wc++-compat"
typedef struct {
#ifndef __GNUC__
char a;
#endif
} EmptyStruct;
+#pragma GCC diagnostic pop
LIBTEST_API int STDCALL
mono_test_marshal_empty_string_array (char **array)
{
ByValStrStruct *ret;
- ret = malloc(sizeof(ByValStrStruct));
+ ret = (ByValStrStruct *)malloc (sizeof (ByValStrStruct));
memset(ret, 'a', sizeof(ByValStrStruct)-1);
ret->a[sizeof(ByValStrStruct)-1] = 0;
LIBTEST_API void STDCALL
class_marshal_test1 (SimpleObj **obj1)
{
- SimpleObj *res = malloc (sizeof (SimpleObj));
+ SimpleObj *res = (SimpleObj *)malloc (sizeof (SimpleObj));
res->str = marshal_strdup ("ABC");
res->i = 5;
GError *error = NULL;
char *s;
- s = g_utf16_to_utf8 (ptr, -1, NULL, NULL, &error);
+ s = g_utf16_to_utf8 ((const gunichar2 *)ptr, -1, NULL, NULL, &error);
if (!s)
return 1;
LIBTEST_API int STDCALL
mono_test_marshal_asany_in (void* ptr)
{
- AsAnyStruct* asAny = ptr;
+ AsAnyStruct *asAny = (AsAnyStruct *)ptr;
int res = asAny->i + asAny->j + asAny->k;
return res;
LIBTEST_API int STDCALL
mono_test_marshal_asany_inout (void* ptr)
{
- AsAnyStruct* asAny = ptr;
+ AsAnyStruct *asAny = (AsAnyStruct *)ptr;
int res = asAny->i + asAny->j + asAny->k;
marshal_free (asAny->s);
LIBTEST_API int STDCALL
mono_test_marshal_asany_out (void* ptr)
{
- AsAnyStruct* asAny = ptr;
+ AsAnyStruct *asAny = (AsAnyStruct *)ptr;
int res = asAny->i + asAny->j + asAny->k;
asAny->i = 10;
buf [0] = 0;
buf [1] = 10;
- ptr = del (&buf);
+ ptr = (guint32 *)del (&buf);
res = ptr [1];
int ret = 0;
gpointer (*mono_method_get_unmanaged_thunk)(gpointer)
- = lookup_mono_symbol ("mono_method_get_unmanaged_thunk");
+ = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_method_get_unmanaged_thunk");
gpointer (*mono_string_new_wrapper)(const char *)
- = lookup_mono_symbol ("mono_string_new_wrapper");
+ = (gpointer (*)(const char *))lookup_mono_symbol ("mono_string_new_wrapper");
- char* (*mono_string_to_utf8)(gpointer)
- = lookup_mono_symbol ("mono_string_to_utf8");
+ char *(*mono_string_to_utf8)(gpointer)
+ = (char *(*)(gpointer))lookup_mono_symbol ("mono_string_to_utf8");
gpointer (*mono_object_unbox)(gpointer)
- = lookup_mono_symbol ("mono_object_unbox");
+ = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_object_unbox");
gpointer (*mono_threads_enter_gc_unsafe_region) (gpointer)
- = lookup_mono_symbol ("mono_threads_enter_gc_unsafe_region");
+ = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_threads_enter_gc_unsafe_region");
void (*mono_threads_exit_gc_unsafe_region) (gpointer, gpointer)
- = lookup_mono_symbol ("mono_threads_exit_gc_unsafe_region");
+ = (void (*)(gpointer, gpointer))lookup_mono_symbol ("mono_threads_exit_gc_unsafe_region");
goto done;
}
- CreateObject = mono_method_get_unmanaged_thunk (create_object_method_handle);
+ CreateObject = (gpointer (*)(gpointer *))mono_method_get_unmanaged_thunk (create_object_method_handle);
if (!CreateObject) {
ret = 3;
goto done;
case 0: {
/* thunks.cs:Test.Test0 */
- void (STDCALL *F)(gpointer*) = test_method;
+ void (STDCALL *F)(gpointer *) = (void (STDCALL *)(gpointer *))test_method;
F (&ex);
break;
}
case 1: {
/* thunks.cs:Test.Test1 */
- int (STDCALL *F)(gpointer*) = test_method;
+ int (STDCALL *F)(gpointer *) = (int (STDCALL *)(gpointer *))test_method;
if (F (&ex) != 42) {
ret = 4;
goto done;
case 2: {
/* thunks.cs:Test.Test2 */
- gpointer (STDCALL *F)(gpointer, gpointer*) = test_method;
+ gpointer (STDCALL *F)(gpointer, gpointer*) = (gpointer (STDCALL *)(gpointer, gpointer *))test_method;
gpointer str = mono_string_new_wrapper ("foo");
if (str != F (str, &ex)) {
ret = 4;
gpointer obj;
gpointer str;
- F = test_method;
+ F = (gpointer (STDCALL *)(gpointer, gpointer, gpointer *))test_method;
obj = CreateObject (&ex);
str = mono_string_new_wrapper ("bar");
gpointer obj;
gpointer str;
- F = test_method;
+ F = (int (STDCALL *)(gpointer, gpointer, int, gpointer *))test_method;
obj = CreateObject (&ex);
str = mono_string_new_wrapper ("bar");
gpointer obj;
gpointer str;
- F = test_method;
+ F = (int (STDCALL *)(gpointer, gpointer, int, gpointer *))test_method;
obj = CreateObject (&ex);
str = mono_string_new_wrapper ("bar");
gpointer str = mono_string_new_wrapper ("Test6");
int res;
- F = test_method;
+ F = (int (STDCALL *)(gpointer, guint8, gint16, gint32, gint64, float, double, gpointer, gpointer *))test_method;
obj = CreateObject (&ex);
res = F (obj, 254, 32700, -245378, 6789600, 3.1415, 3.1415, str, &ex);
case 7: {
/* thunks.cs:Test.Test7 */
- gint64 (STDCALL *F)(gpointer*) = test_method;
+ gint64 (STDCALL *F)(gpointer*) = (gint64 (STDCALL *)(gpointer *))test_method;
if (F (&ex) != G_MAXINT64) {
ret = 4;
goto done;
double a6;
gpointer a7;
- F = test_method;
+ F = (void (STDCALL *)(guint8 *, gint16 *, gint32 *, gint64 *, float *, double *,
+ gpointer *, gpointer *))test_method;
F (&a1, &a2, &a3, &a4, &a5, &a6, &a7, &ex);
if (ex) {
case 9: {
/* thunks.cs:Test.Test9 */
void (STDCALL *F)(guint8*, gint16*, gint32*, gint64*, float*, double*,
- gpointer*, gpointer*);
+ gpointer*, gpointer*);
guint8 a1;
gint16 a2;
double a6;
gpointer a7;
- F = test_method;
+ F = (void (STDCALL *)(guint8 *, gint16 *, gint32 *, gint64 *, float *, double *,
+ gpointer *, gpointer *))test_method;
F (&a1, &a2, &a3, &a4, &a5, &a6, &a7, &ex);
if (!ex) {
goto done;
}
- F = test_method;
+ F = (void (STDCALL *)(gpointer *, gpointer *))test_method;
F (&obj1, &ex);
if (ex) {
goto done;
}
- a1 = mono_object_unbox (obj);
+ a1 = (TestStruct *)mono_object_unbox (obj);
if (!a1) {
ret = 6;
goto done;
a1->A = 42;
a1->B = 3.1415;
- F = test_method;
+ F = (int (STDCALL *)(gpointer *, gpointer *))test_method;
- res = F (obj, &ex);
+ res = F ((gpointer *)obj, &ex);
if (ex) {
ret = 7;
goto done;
goto done;
}
- a1 = mono_object_unbox (obj);
+ a1 = (TestStruct *)mono_object_unbox (obj);
if (!a1) {
ret = 6;
goto done;
}
- F = test_method;
+ F = (void (STDCALL *)(gpointer, gpointer *))test_method;
F (obj, &ex);
if (ex) {
TestStruct *a1;
gpointer obj;
- F = test_method;
+ F = (gpointer (STDCALL *)(gpointer *))test_method;
obj = F (&ex);
if (ex) {
goto done;
}
- a1 = mono_object_unbox (obj);
+ a1 = (TestStruct *)mono_object_unbox (obj);
if (a1->A != 42) {
ret = 5;
goto done;
}
- a1 = mono_object_unbox (obj);
+ a1 = (TestStruct *)mono_object_unbox (obj);
if (!a1) {
ret = 6;
a1->A = 42;
a1->B = 3.1415;
- F = test_method;
+ F = (void (STDCALL *)(gpointer, gpointer *))test_method;
F (obj, &ex);
if (ex) {
static void
call_managed (gpointer arg)
{
- SimpleDelegate del = arg;
+ SimpleDelegate del = (SimpleDelegate)arg;
call_managed_res = del (42);
}
int res;
pthread_t t;
- res = pthread_create (&t, NULL, (gpointer)call_managed, del);
+ res = pthread_create (&t, NULL, (gpointer (*)(gpointer))call_managed, del);
g_assert (res == 0);
pthread_join (t, NULL);
LIBTEST_API char* STDCALL
mono_test_marshal_return_lpstr (void)
{
- char *res = marshal_alloc (4);
+ char *res = (char *)marshal_alloc (4);
strcpy (res, "XYZ");
return res;
}
LIBTEST_API gunichar2* STDCALL
mono_test_marshal_return_lpwstr (void)
{
- gunichar2 *res = marshal_alloc (8);
+ gunichar2 *res = (gunichar2 *)marshal_alloc (8);
gunichar2* tmp = g_utf8_to_utf16 ("XYZ", -1, NULL, NULL, NULL);
memcpy (res, tmp, 8);
int
main (void)
{
- unsigned char *random_mem = malloc (POOL_SIZE);
- unsigned char *reference = malloc (POOL_SIZE);
- unsigned char *playground = malloc (POOL_SIZE);
+ unsigned char *random_mem = (unsigned char *)malloc (POOL_SIZE);
+ unsigned char *reference = (unsigned char *)malloc (POOL_SIZE);
+ unsigned char *playground = (unsigned char *)malloc (POOL_SIZE);
long *long_random_mem;
int i, offset, size, src_offset, dest_offset;
static void
free_node (void *n)
{
- node_t *node = n;
+ node_t *node = (node_t *)n;
assert (node->state == STATE_BUSY);
node->state = STATE_OUT;
}
static void*
worker (void *arg)
{
- thread_data_t *thread_data = arg;
+ thread_data_t *thread_data = (thread_data_t *)arg;
MonoThreadHazardPointers *hp;
int skip = thread_data->skip;
int i, j;
memcpy (b2, base, len);
qsort (b1, nel, sizeof (teststruct_t*), compare_teststructs2);
- qsort_test_struct (b2, nel);
+ qsort_test_struct ((teststruct_t **)b2, nel);
assert (!memcmp (b1, b2, len));
size_t member_size,
BinarySearchComparer comparer)
{
- const char *base = array;
+ const char *base = (const char *)array;
size_t lim;
int cmp;
const void *p;
while (p > align_end)
*--p = *--s;
- word_start = align_up (start);
+ word_start = (char *)align_up (start);
bytes_to_memmove = p - word_start;
p -= bytes_to_memmove;
s -= bytes_to_memmove;
static void
conc_table_free (gpointer ptr)
{
- conc_table *table = ptr;
+ conc_table *table = (conc_table *)ptr;
g_free (table->kvs);
g_free (table);
}
hp = mono_hazard_pointer_get ();
retry:
- table = get_hazardous_pointer ((gpointer volatile*)&hash_table->table, hp, 0);
+ table = (conc_table *)get_hazardous_pointer ((gpointer volatile*)&hash_table->table, hp, 0);
table_mask = table->table_size - 1;
kvs = table->kvs;
i = hash & table_mask;
#define MONO_LLS_FOREACH_FILTERED(list, element, filter_func, type) {\
MonoLinkedListSetNode *__cur; \
- for (__cur = (list)->head; __cur; __cur = mono_lls_pointer_unmask (__cur->next)) \
+ for (__cur = (list)->head; __cur; __cur = (MonoLinkedListSetNode *)mono_lls_pointer_unmask (__cur->next)) \
if (!mono_lls_pointer_get_mark (__cur->next)) { \
(element) = (type)__cur; \
if (!filter_func (element)) continue;
count = 16;
else
count *= 2;
- buf = g_realloc (buf, count * sizeof (void*));
+ buf = (void **)g_realloc (buf, count * sizeof (void*));
}
buf [i++] = GINT_TO_POINTER (pid);
}
if (!mono_threads_is_coop_enabled ())
return;
- info = cookie;
+ info = (MonoThreadInfo *)cookie;
if (!info)
return;
if (!mono_threads_is_coop_enabled ())
return;
- info = cookie;
+ info = (MonoThreadInfo *)cookie;
if (!info)
return;
struct sigaction previous_sa;
int ret;
- sa.sa_sigaction = handler;
+ sa.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
sigfillset (&sa.sa_mask);
sa.sa_flags = SA_SIGINFO | flags;
#if MONO_ARCH_HAS_MONO_CONTEXT
MonoContext tmp = current->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, current->async_target, current->user_data);
- current->async_target = current->user_data = NULL;
+ current->user_data = NULL;
+ current->async_target = NULL;
mono_monoctx_to_sigctx (&tmp, context);
#else
g_error ("The new interruption machinery requires a working mono-context");
token->callback = callback;
token->data = data;
- previous_token = InterlockedCompareExchangePointer ((gpointer*) &info->interrupt_token, token, NULL);
+ previous_token = (MonoThreadInfoInterruptToken *)InterlockedCompareExchangePointer ((gpointer*) &info->interrupt_token, token, NULL);
if (previous_token) {
if (previous_token != INTERRUPT_STATE)
info = mono_thread_info_current ();
g_assert (info);
- previous_token = InterlockedExchangePointer ((gpointer*) &info->interrupt_token, NULL);
+ previous_token = (MonoThreadInfoInterruptToken *)InterlockedExchangePointer ((gpointer*) &info->interrupt_token, NULL);
/* only the installer can uninstall the token */
g_assert (previous_token);
info = mono_thread_info_current ();
g_assert (info);
- previous_token = InterlockedCompareExchangePointer ((gpointer*) &info->interrupt_token, NULL, INTERRUPT_STATE);
+ previous_token = (MonoThreadInfoInterruptToken *)InterlockedCompareExchangePointer ((gpointer*) &info->interrupt_token, NULL, INTERRUPT_STATE);
g_assert (previous_token == NULL || previous_token == INTERRUPT_STATE);
THREADS_INTERRUPT_DEBUG ("interrupt clear self tid %p previous_token %p\n", mono_thread_info_get_tid (info), previous_token);
memset (&ifc, 0, sizeof (ifc));
ifc.ifc_len = IFCONF_BUFF_SIZE;
- ifc.ifc_buf = g_malloc (IFCONF_BUFF_SIZE); /* We can't have such huge buffers on the stack. */
+ ifc.ifc_buf = (char *)g_malloc (IFCONF_BUFF_SIZE); /* We can't have such huge buffers on the stack. */
if (ioctl (fd, SIOCGIFCONF, &ifc) < 0)
goto done;
++if_count;
}
- result_ptr = result = g_malloc (if_count * mono_address_size_for_family (family));
+ result = (char *)g_malloc (if_count * mono_address_size_for_family (family));
+ result_ptr = (char *)result;
FOREACH_IFR (ifr, ifc) {
if (ifr->ifr_name [0] == '\0')
continue;
projects / mono.git / commitdiff