static void
process_image (MonoImage *image, gboolean all) {
int i;
const MonoTableInfo *t;
MonoClass *klass;
MonoMethod *entry;
guint32 eptoken;
if (verbose)
g_print ("#processing image: %s\n", mono_image_get_name (image));
eptoken = mono_image_get_entry_point (image);
if (eptoken) {
entry = mono_get_method (image, eptoken, NULL);
add_types_from_method (entry);
}
/* we always add the <Module> type */
klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | 1);
handle_type (klass, all? TYPE_ALL: TYPE_BASIC);
if (all) {
t = mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
for (i = 1; i < mono_table_info_get_rows (t); ++i) {
klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | (i + 1));
handle_type (klass, all? TYPE_ALL: TYPE_BASIC);
}
}
}
static void
output_assembly (MonoAssembly *assembly, MonoAssembly *assembly2, FILE *outfile)
{
MonoImage *image = mono_assembly_get_image (assembly);
fprintf (outfile, "\t<assembly name=\"%s\" guid=\"%s\" filename=\"%s\"/>\n",
mono_image_get_name (image), mono_image_get_guid (image), mono_image_get_filename (image));
}
void CPipeServer::GetImageName()
{
void *image=(void *)ReadQword();
char *s=mono_image_get_name(image);
WriteWord(strlen(s));
Write(s, strlen(s));
}
void
mono_error_set_bad_image (MonoError *oerror, MonoImage *image, const char *msg_format, ...)
{
MonoErrorInternal *error = (MonoErrorInternal*)oerror;
mono_error_prepare (error);
error->error_code = MONO_ERROR_BAD_IMAGE;
error->assembly_name = image ? mono_image_get_name (image) : "<no_image>";
set_error_message ();
}
void
mono_error_set_bad_image (MonoError *error, MonoImage *image, const char *msg_format, ...)
{
char *str;
SET_ERROR_MSG (str, msg_format);
mono_error_set_specific (error, MONO_ERROR_BAD_IMAGE, str);
if (image)
mono_error_set_first_argument (error, mono_image_get_name (image));
}
static void
foreach_image (const gpointer key, const gpointer val, gpointer user_data)
{
MonoImage *image = key;
const char* aname;
aname = mono_image_get_name (image);
/* later print the guid as well to prevent mismatches */
fprintf (outf, "[%s]\n", aname);
g_hash_table_foreach (type_table, foreach_type, image);
}
/*
* use the equivalent lookup code from the GAC when available.
* Depending on state, this should give something like:
* aname/version-pubtoken/
* aname/version/
* aname
*/
static char*
get_assembly_filename (MonoImage *image, int state)
{
switch (state) {
case 0:
return g_strdup (mono_image_get_name (image));
default:
return NULL;
}
}
static void
output_image (gpointer key, gpointer value, gpointer user_data)
{
MonoImage *image = (MonoImage*)key;
PerImageData *image_data = (PerImageData*)value;
MonoProfiler *prof = (MonoProfiler*)user_data;
char *tmp, *outfile_name;
FILE *outfile;
int i, err;
ForeachData data;
tmp = g_strdup_printf ("%s/.mono/aot-profile-data", g_get_home_dir ());
if (!g_file_test (tmp, G_FILE_TEST_IS_DIR)) {
#ifdef PLATFORM_WIN32
err = mkdir (tmp);
#else
err = mkdir (tmp, 0777);
#endif
if (err) {
fprintf (stderr, "mono-profiler-aot: Unable to create output directory '%s': %s\n", tmp, g_strerror (errno));
exit (1);
}
}
i = 0;
while (TRUE) {
outfile_name = g_strdup_printf ("%s/%s-%d", tmp, mono_image_get_name (image), i);
if (!g_file_test (outfile_name, G_FILE_TEST_IS_REGULAR))
break;
i ++;
}
printf ("Creating output file: %s\n", outfile_name);
outfile = fopen (outfile_name, "w+");
g_assert (outfile);
fprintf (outfile, "#VER:%d\n", 2);
data.prof = prof;
data.outfile = outfile;
data.image = image;
g_list_foreach (image_data->methods, foreach_method, &data);
}
gboolean
mono_trace_eval (MonoMethod *method)
{
int include = 0;
int i;
for (i = 0; i < trace_spec.len; i++){
MonoTraceOperation *op = &trace_spec.ops [i];
int inc = 0;
switch (op->op){
case MONO_TRACEOP_ALL:
inc = 1; break;
case MONO_TRACEOP_PROGRAM:
if (trace_spec.assembly && (method->klass->image == mono_assembly_get_image (trace_spec.assembly)))
inc = 1; break;
case MONO_TRACEOP_WRAPPER:
if ((method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) ||
(method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE))
inc = 1; break;
case MONO_TRACEOP_METHOD:
if (mono_method_desc_full_match ((MonoMethodDesc *) op->data, method))
inc = 1; break;
case MONO_TRACEOP_CLASS:
if (strcmp (method->klass->name_space, op->data) == 0)
if (strcmp (method->klass->name, op->data2) == 0)
inc = 1;
break;
case MONO_TRACEOP_ASSEMBLY:
if (strcmp (mono_image_get_name (method->klass->image), op->data) == 0)
inc = 1; break;
case MONO_TRACEOP_NAMESPACE:
if (strcmp (method->klass->name_space, op->data) == 0)
inc = 1;
case MONO_TRACEOP_EXCEPTION:
break;
}
if (op->exclude){
if (inc)
include = 0;
} else if (inc)
include = 1;
}
return include;
}
void
mono_config_for_assembly (MonoImage *assembly)
{
ParseState state = {NULL};
int got_it = 0, i;
char *aname, *cfg, *cfg_name;
const char *bundled_config;
const char *home;
state.assembly = assembly;
bundled_config = mono_config_string_for_assembly_file (assembly->module_name);
if (bundled_config) {
state.user_data = (gpointer) "<bundled>";
mono_config_parse_xml_with_context (&state, bundled_config, strlen (bundled_config));
}
cfg_name = g_strdup_printf ("%s.config", mono_image_get_filename (assembly));
mono_config_parse_file_with_context (&state, cfg_name);
g_free (cfg_name);
cfg_name = g_strdup_printf ("%s.config", mono_image_get_name (assembly));
home = g_get_home_dir ();
for (i = 0; (aname = get_assembly_filename (assembly, i)) != NULL; ++i) {
cfg = g_build_filename (mono_get_config_dir (), "mono", "assemblies", aname, cfg_name, NULL);
got_it += mono_config_parse_file_with_context (&state, cfg);
g_free (cfg);
#ifdef TARGET_WIN32
cfg = g_build_filename (home, ".mono", "assemblies", aname, cfg_name, NULL);
got_it += mono_config_parse_file_with_context (&state, cfg);
g_free (cfg);
#endif
g_free (aname);
if (got_it)
break;
}
g_free (cfg_name);
}
static void
output_method (MonoMethod *method, gpointer dummy, MonoProfiler *prof)
{
MonoMethodHeader *header;
char *classname;
char *tmpsig;
char *tmpname;
FILE *outfile;
MonoClass *klass;
MonoImage *image;
outfile = prof->outfile;
header = mono_method_get_header (method);
tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
tmpsig = g_markup_escape_text (tmpsig, strlen (tmpsig));
klass = mono_method_get_class (method);
classname = mono_type_get_name (mono_class_get_type (klass));
image = mono_class_get_image (klass);
tmpname = mono_method_get_name (method);
tmpname = g_markup_escape_text (tmpname, strlen (tmpname));
fprintf (outfile, "\t<method assembly=\"%s\" class=\"%s\" name=\"%s (%s)\" token=\"%d\">\n",
mono_image_get_name (image),
classname, tmpname,
tmpsig, mono_method_get_token (method));
g_free (tmpsig);
g_free (tmpname);
fprintf (outfile, "\t\t");
count = 0;
prev_offset = 0;
mono_profiler_coverage_get (prof, method, output_entry);
fprintf (outfile, "\n");
fprintf (outfile, "\t</method>\n");
}
//#####################################################################
// Function listAssembliesHelper
//#####################################################################
static void listAssembliesHelper(MonoAssembly* assembly, MonoSystem* this_ptr) {
MonoImage* image = mono_assembly_get_image(assembly);
printf("Assembly Image: %s\n", mono_image_get_name(image));
}
static gboolean
collect_coverage_for (MonoProfiler *prof, MonoMethod *method)
{
int i;
char *classname;
char *fqn;
MonoMethodHeader *header;
gboolean has_positive, found;
guint32 iflags, flags, code_size;
MonoClass *klass;
MonoImage *image;
flags = mono_method_get_flags (method, &iflags);
if ((iflags & 0x1000 /*METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL*/) ||
(flags & 0x2000 /*METHOD_ATTRIBUTE_PINVOKE_IMPL*/))
return FALSE;
//if (method->wrapper_type != MONO_WRAPPER_NONE)
// return FALSE;
klass = mono_method_get_class (method);
image = mono_class_get_image (klass);
/* Hacky way of determining the executing assembly */
if (! prof->outfile_name && (strcmp (mono_method_get_name (method), "Main") == 0)) {
prof->outfile_name = g_strdup_printf ("%s.cov", mono_image_get_filename (image));
}
/* Check filters */
if (prof->filters) {
/* Check already filtered classes first */
if (g_hash_table_lookup (prof->filtered_classes, klass))
return FALSE;
classname = mono_type_get_name (mono_class_get_type (klass));
fqn = g_strdup_printf ("[%s]%s", mono_image_get_name (image), classname);
// Check positive filters first
has_positive = FALSE;
found = FALSE;
for (i = 0; i < prof->filters->len; ++i) {
char *filter = g_ptr_array_index (prof->filters_as_str, i);
if (filter [0] == '+') {
filter = &filter [1];
if (strstr (fqn, filter) != NULL)
found = TRUE;
has_positive = TRUE;
}
}
if (has_positive && !found)
return FALSE;
for (i = 0; i < prof->filters->len; ++i) {
// Is substring search suffices ???
// GPatternSpec *spec = g_ptr_array_index (filters, i);
// if (g_pattern_match_string (spec, classname)) {
char *filter = g_ptr_array_index (prof->filters_as_str, i);
if (filter [0] == '+')
continue;
// Skip '-'
filter = &filter [1];
if (strstr (fqn, filter) != NULL) {
g_hash_table_insert (prof->filtered_classes, klass, klass);
return FALSE;
}
}
g_free (fqn);
g_free (classname);
}
header = mono_method_get_header (method);
mono_method_header_get_code (header, &code_size, NULL);
if (code_size > 20000) {
exit (1);
g_warning ("Unable to instrument method %s:%s since it is too complex.", mono_class_get_name (klass), mono_method_get_name (method));
return FALSE;
}
g_hash_table_insert (prof->methods, method, method);
g_hash_table_insert (prof->classes, klass, klass);
g_hash_table_insert (prof->assemblies, mono_image_get_assembly (image), mono_image_get_assembly (image));
return TRUE;
}