Instead of using mono_valloc we create a temp file and unlink it. With this we can have the right
mmap semantics regarding CoW and access rights.
This does simplify the code too by completely removing the mapping kind.
BindingList subscribes to PropertyChanged events of eligible contained objects. Iff the PropertyName provided is valid,
the list event's ListChangedEventArgs will also contain a PropertyDescriptor.
This is to match MS behavior.
Remove the "ConnectionState" from the connection list before closing the connection,
this should avoid ServicePoint.SendRequest() ever crashing with a NullReferenceException
due to getting a null return value from WebConnectionGroup.GetConnection().
The is no reason to ever invoke the callback on the ThreadPool,
it would in fact only cause trouble.
Marek's commit db92449f was correct, I removed the commented out
code and the no longer used method.
Thanks a lot for Martin Potter to find and report the race condition
which was causing the problem.
ServicePointManager.RecycleServicePoints() was a left-over from the
old times when we didn't have an idle-timer based approach.
This patch includes a few fixes:
* CreateNew will actually create a memory map file, the previous logic
in MemoryMapImpl.Open was wrong, and would fail if the file did not
exist. We now cope with this (bug #20052 was caused by this).
* Some exceptions were wrong, so this patch updates the
exceptions being thrown to be the right ones
* On Mobile, we inverted the logic to ensure that capacity must be
bigger or equal than the file size (which is what the API needs to do),
previously it performed the opposite test.
Added tests that match the behavior on .NET for this.
When loading assemblies, we must ensure that a basedir is provided otherwise
things like custom attributes and Type.GetType won't be able to load sibling
assemblies when basedir is not the same of the domain.
The compiler seems to ignore reference assemblies with a full path when the
-lib: directive is passed, so things like:
-lib:FOO -r:BAR/bar.dll
Would resolve bar.dll to FOO/bar.dll, instead of BAR/bar.dll.
This is a problem with the test suite as it needs to reference the
final build of System.Configuration from $(the_libdir_base) and not
the intermediate step.
To work around this issue, we introduce "test_remove" variable that is
a piece of text that will be removed from the TEST_COMPILE variable
when this is evaluated.
This means that it gets CSCOMPILE and then it removes the bits that we
are not interested in.
Now a solution turns into a project with "BuildingSolutionFile" property
which is assigned by SolutionParser and subsequently gets _ExplicitReference
that is to store path to mscorlib.dll and thence projects build.
Issue: The previous code, with new tests [1], failed when the linker was
enabled.
That was caused because the code looks for the Keys and Item properties
getter using reflection. The linker handled that imperfectly (it left
some holes), in part because:
* System.Collections.Generic.IDictionary`2 does not implement
System.Collections.IDictionary; and
* It preserved the explicit methods - not the implicit one that were
used the the reflection-based code;
That later fact is also a bug (without the linker involvment) and solved
by this commit. A unit test was added to show the issue (NRE).
The patch also avoid the use of reflection for IDictionary since we can
simply typecast to get the same result (without the additional cost).
Also simplify the code a little bit, there's no need to have separate
code paths for ARM64, since using the correct objc_msgSend signature
works on all architectures.
MonoJenkins repeatedly complains about:
mono-counters.c:xxx:1: warning: function declaration isn't a prototype
[-Wstrict-prototypes]
This is caused by the missing declaration of the function arguments.
This change is released under the MIT license.
This silences the following gcc/clang warnings from MonoJenkins:
sgen-tarjan-bridge.c:395:2: warning: ISO C90 forbids mixed declarations and code
proflog.c:1942:2: warning: ISO C90 forbids mixed declarations and code
proflog.c:1999:3: warning: ISO C90 forbids mixed declarations and code
decode.c:2409:6: warning: ISO C90 forbids mixed declarations and code
decode.c:2433:6: warning: ISO C90 forbids mixed declarations and code
Moving the declarations to the beginning of the blocks is sufficient
to silence the warnings.
This change is released under the MIT license.
Visual C++ does not support intermixed declarations and code and
errors out with:
error C2275: 'guint' : illegal use of this type as an expression
This also silences gcc/clang warnings such as:
mono-counters.c:xxx:3: warning: ISO C90 forbids mixing declarations
and code
In this case this can be fixed easily by skipping the intermediate
variable.
Based on pull request #1043 by J-M <[email protected]>
This change is released under the MIT license.
Currently the flag is passed on the command line, but this is
problematic for us since our xbuild implementation does not seem to support
the attribute that generates the /keyfile: argument
The use case for this function compared to the one that take MonoClass/MonoImage is for lookups
and the failed names are usually freshly alloc'd.
Fix a leak in class.c usage of mono_error_set_type_load_name.
Remove all internal usages of mono_custom_attrs_construct and replace with mono_custom_attrs_construct_by_type
that takes a MonoError.
Introduce mono_custom_attrs_get_attr_checked and replace usage of the old one where it's needed.
The LOCAL_MCS_FLAGS are passed to the compiler before the standard
directory for the profile. This is important both for correctness,
and also assists the solution generator, since we can now precisely
determine which intermediate project must be referenced.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=19991
The original Mono.Unix.Native.Errno design used the Linux <errno.h>
constants and values...largely because it was easy.
As it turns out, this is also incomplete. The getxattr(2) defines
ENOATTR as a possible error code. On Linux, ENOATTR is an alias for
ENODATA [0]. On OS X, ENOATTR is _not_ an alias. Furthermore, since
ENOATTR is not a Linux errno value (it's an alias!),
Mono_Posix_ToErrno() couldn't check for the native ENOATTR value, so a
Syscall.GetLastError() call after a failing Syscall.getxattr() would
fail with a System.ArgumentOutOfRangeException:
$ csharp -r:Mono.Posix.dll
Mono C# Shell, type "help;" for help
Enter statements below.
csharp> using Mono.Unix.Native;
csharp> byte[] value;
csharp> Syscall.getxattr(".", "test", out value);
-1
csharp> Syscall.GetLastError();
System.ArgumentOutOfRangeException: Current platform doesn't support this value.
Parameter name: value
93
at Mono.Unix.Native.NativeConvert.ThrowArgumentException (System.Object value) [0x00000] in <filename unknown>:0
at Mono.Unix.Native.NativeConvert.ToErrno (Int32 value) [0x00000] in <filename unknown>:0
at Mono.Unix.Native.Stdlib.GetLastError () [0x00000] in <filename unknown>:0
The fix is to add an Errno.ENOATTR field [1].
The complication is one of what enum value to use: at present, the
Errno values are based on the Linux values. In the case of ENOATTR
(and others), there is no Linux value. Meanwhile, there is the
possibility of additional Linux error values; how do we future proof
ourselves?
This isn't a perfect solution, but it should punt the problem down the
road a bit: Errno is an `int` enum, and thus has large range. To
support the OS X values, we add 1000 to the OS X error value.
/* OS X: <errno.h> */
#define ENOATTR 93 /* Attribute not found */
// C# Errno enum:
public enum Errno : int {
// ...
ENOATTR = 1093,
}
This gives us 0..1000 for POSIX+Linux error codes, 1000..2000 for OS X
specific error codes, and as new platforms require additional support
they can all start at multiples of 1000.
Hopefully no single *nix platform will add more than 1000 error codes...
[0]: http://linux.die.net/man/2/getxattr
[1]: Related part of the fix: add all the OTHER <errno.h> values that
OS X includes but weren't included in the Errno enum.
From Dick Porter:
The IPv6 address parser misses some syntax errors, and can become confused by
addresses that at first glance look IPv4 compatible. The attach patch contains
the following fixes:
Don't fail to parse an address if we mistakenly thought it was IPv4 compatible
or mapped, just treat it as IPv6.
Fix IPv4-compatible and mapped address formatting in ToString().
Fix parsing of colons - specifically occurrences of ':::'.
Make sure blocks of digits are no longer than 4 characters.
Add some more parsing tests to Mono's NUnit test suite.
Add a NUnit test for bogus IPv6 addresses.
- ITaskFactory could return null, so check the return value.
- UsingTask descendants could have property references, so use ExpandString.
- TaskBody was not appropriately passed to internal structure.
And since the code is almost the same as existing ProjectInstance one, just
make it identical. (Should be unified, but depends on members, hence TODO.)
This reverts commit 3f7ad8f457.
WebProxy.BypassProxyOnLocal is really broken! There seems to be no
way of actually bypassing a proxy on local connections.
When libgdiplus is configured as sibling, it is available in the
libgdiplus_loc path. This path was added to runtime/mono/config, but
it was later overridden by the prefix-based path.
Using the same approach as for libMonoPosixHelper fixed the lookup of
the library (performed, for example, when testing
MonoTests.System.Drawing without installing libgdiplus).
This change is released under the MIT license.
When compiling mono with icc (ICC) 14.0.0 20130728 the build fails on
CC libmonoruntimesgen_la-sgen-stw.lo
with the following error:
Assembler messages:
Error: suffix or operands invalid for `lea'
Apparently icc (or the assembler) dislikes the rip-based LEA
operation. This can be worked around by manually assembling the
instruction and replacing it with the corresponding byte sequence.
This change is released under the MIT license.
So, it seems that where MSBuildExtensionsPath* is evaluated should be likely
evaluated multiple times, and find actually matching files in one of those.
F# build .targets file expects that.
Since it is almost impossible to assume in which usage scenario it is going
to be evaluated multiple times (those properties can be used anywhere by
simple $(...) syntax), it limits the attempts only for Import() so far.
Old xbuild actually does so too. That way, the particular F# issue is fixed.
Added local targets (csproj-local) to all the assemblies that have
staged builds to dump their build information for the underlying
dependencies.
This information is needed to create the new Visual Studio csproj
files.
This commit also updates the collected build metadata from running:
make update-csproj
make package-inputs
As described in msvc/scripts/README
To be precise, now the implementation returns ItemSpec for ToString().
WriteLinesIntoFile task writes ITaskItem[] lines into a file, without calling
ItemSpec.
Maybe it is better to fix Tasks.dll but I'm unsure about xbuild compatibility.
This missing ToString() override caused target framework monikor output
to become invalid source file (i.e. it used to write ItemSpec as code(!) but
this ITaskItem impl. in BuildEngine4 just wrote its type name as .ToString()
result).
We must use the secxml library directory to reference System, not
bare.
The bare build does not contain a full signature for some interfaces
(there is a using XmlNode = object in a few interfaces that
System.Configuration depends on).
So System.Configuration must reference the System that has been
compiled with XML support.
The parallelization is done by overriding the default "all" target
and instead of using the serial subdirectory processing that goes
over the SUBDIR and xx_SUBDIR rules, we turn the list of
subdirectories into the name of the target, for example:
System.Collections.Concurrent
becomes:
../../class/lib/net_4_5/Facades/System.Collections.Concurrent.dll
Then a pattern is added to handle that rule:
$(target_dir)/%.dll:
This allows the build to be parallized.
This patch introduces an infrastructure to stage the builds for the core
assemblies that have cyclic dependencies. This deals directly with
the following cycle:
System.dll requires:
System.Configuration.dll
Mono.Security.dll
System.Xml.dll
They all require System.dll to be built
System.Xml requires:
System.dll
System.Configuration.dll
System.Security.dll requires:
System.dll
Mono.Security.dll
System.Xml.dll
Principle
=========
The patch works by directing the build infrastructure to place
intermediate build steps on their own directory. For example the
first System.dll build that only takes a dependency in mscorlib.dll is
placed not under the final directory but on a subdirectory called
"bare".
The second time that System.dll is built (after Mono.Security and
System.Xml have been built) is placed on the "secxml" directory.
The third time is the final build, and that one ends in the profile
directory.
The same principle is applied to System.Xml.
Better Dependency Tracking
==========================
To handle the multiple stages, the new Makefiles for the various
parties involved in this loop are now able to build their
dependencies. This means that typing "make" on System.Security or
System.Xml or System will build all of the intermediate steps as
required, without needing the toplevel Makefile to perform multiple
build shots to incrementally build the result.
Bug fixes
=========
We must have regressed at some point the build of System.Xml as we
were only doing one build of it, one without System.Configuration
support. This patch introduces back the changes to build System.Xml
in two steps.
This patch fixes the setup where we end up rebuilding System.dll and
overwriting it two times as the build progresses as a side effect
(this is what required LIBRARY_USE_INTERMEDIATE_FILE).
Details
=======
library.make:
Introduces a new "the_libdir_base" which is the raw directory
where the final output will go. This points to the same location
that libdir_base previously pointed to.
The existing libdir_base is modified to contain an optional
"intermediate" directory, where intermediate builds can be
placed.
The Screen.FromRectangle method was too simple minded. It did not try to
find the best match for a screen when the system has more than one screen.
The new implementation makes at least some effort to find the closest
screen with the most overlap with the rectangle.
The number of displays and sizes can be retrieved with the help of
libXinerama. The implementation was done in a way that is backwards
compatible, so on non-Linux systems or when libXinerama is not
available the behavior will be the same as before.
Also fixed the implementation of FormStartPosition.CenterScreen to
bring up the form centered on the current display (with the current
display being either the screen the top left corner of the owner
form is on, or if there is no owner the screen that has the mouse
pointer). This fixes Novell bug #325669 on Linux
(https://bugzilla.novell.com/show_bug.cgi?id=325669).
We now have a pair of functions to match mono_thread_info_safe_suspend_sync.
They should be used instead of mono_thread_resume as they do the right thing
WRT to hazard pointers.
mono_thread_info_lookup leaves the current value on hazard pointer 1,
so all callers must clean it afterwards. This was not done in all cases
by mono_thread_info_resume.
This function was called from code that uses hazard pointers, so their values could get overridden.
Besides that, we did not clean up the hazard pointer table afterwards, which is wrong too.
Right now all the input parameters are computed based on string, and any
metadata items are simply chopped out when it is passed to a Task.
To fix this, we need to replace ExpandString() use with more complicated
evaluator that takes ITaskItem into consideration.
(It is not complete as of now; evaluation method needs to be replaced and
any regressions need to be fixed.)
(Reported by directhex on #mono 2014-05-14 at 14:28 EDT.)
When importing Microsoft XML Documentation, if a //altmember/@name,
//exception/@name, or //permission/@name attribute is encountered then
mdoc will die with a NullReferenceException:
mdoc: System.NullReferenceException: Object reference not set to an instance of an object
at Mono.Documentation.MsxdocDocumentationImporter.ImportDocumentation (Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.MakeDocNode (Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.UpdateMember (Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.MakeMember (System.Xml.XmlDocument doc, Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.DoUpdateType2 (System.String message, System.Xml.XmlDocument basefile, Mono.Cecil.TypeDefinition type, System.String output, Boolean insertSince)
at Mono.Documentation.MDocUpdater.StubType (Mono.Cecil.TypeDefinition type, System.String output)
at Mono.Documentation.MDocUpdater.DoUpdateType (Mono.Cecil.TypeDefinition type, System.String basepath, System.String dest)
at Mono.Documentation.MDocUpdater.DoUpdateAssembly (Mono.Cecil.AssemblyDefinition assembly, System.Xml.XmlElement index_types, System.String source, System.String dest, System.Collections.Generic.HashSet`1 goodfiles)
at Mono.Documentation.MDocUpdater.DoUpdateAssemblies (System.String source, System.String dest)
at Mono.Documentation.MDocUpdater.Run (IEnumerable`1 args)
at Mono.Documentation.MDoc.Run (System.String[] args)
at Mono.Documentation.MDoc.Main (System.String[] args)
The cause of the NullReferenceException is due to inconsistent
checking: we check that _either_ `child.Attributes["cref"]` OR
`child.Attributes["name"]` is not null, and if one of them IS non-null
then we just grab `child.Attributes["cref"].Value`, which will throw a
NullReferenceException if the @name attribute was present but not the
@cref attribute.
The fix is to be consistent: once we grab an XmlAttribute, use the
already looked up XmlAttribute, don't re-look it up.
For a variety of reasons, we need to bump the assembly version of
System.Net.Http.dll to "4.0.0.0" (from 2.0.5.0) on our MOBILE
profiles, lest much pain and suffering occur, e.g.:
http://motzcod.es/post/78863496592/portable-class-libraries-httpclient-so-happy
> For some reason at compile time the facades don’t kick in
> properly and it tries to use the NuGet version of
> System.Net.Http which has some specific functionality for
> older platforms. ...
> All you need to do is create a new app.config file in your
> Android and iOS project.
The need to create a custom app.config is ugly and something
to be avoided. Setting our System.Net.Http.dll version to
v4.0.0.0 removes the need for the custom app.config.
The two races in question are:
In signal_thread_state_change we need to block the target from
further waiting before we signal it or otherwise it might miss the
broadcast asking it to wakeup.
In mono_thread_request_interruption we need to ensure we self interrupt
before returning from the signal handler.
Unblock the GC suspend/restart signals and SIGCHLD. Those are required to make the GC
and process watching work.
The SIGCHLD issue was found on mod_mono that fork a process with that signal blocked.
The GC signals are been preemptively unblocked as we can never know what sort of sig mask
we'll start with.
This merely introduces a more readable version of some of the constants that
were hardcoded on the source code.
There is a suspect value "20" that was on the original source code, that
stands for VNodeLink and VNodeExtend, but perhaps the original author
meant to say VNodeRename. In any case, it seems like we should catch all
of them (except for Revoke).
The section mapping system wasn't being initialized and used properly since some ifdefs had
been left in the source code. This caused a null reference exception while trying to perform
some HTTP requests and, as the result, broke Xamarin Studio activation.
Two main way to dump :
- per Time : equivalent to a --stats but every seconds, useful to see the overall evolution of all counters
- per Category : print sample values grouped per category and counters, useful to see the evolution of a specific counter over time
This variables are respectively :
- the list of all counters
- the list of all counters grouped by sections
- the list of all counters groupes by sample value timestamps and sections
Counter : contains metadata concerning a counter. There is one in memory per counter index (right now ~100).
CounterValue : represent a sample value of a counter.
CounterList : it is a utility struct that contains a list of counters.
CounterSection : represent all the counters that are in this sections. Used only when we sort counters per category.
CounterTimestamp : represent all the counters that have a sample value at this timestamp. Used only when we sort counters per time.
It's now also much more compatible with the subtleties of
the MS .NET parser and includes a substantial test suite.
Fixes BXC19542 - Broken F# Error Reports
Since we are invoking make recursively to satisfy the dependencies
for any of the cyclic components, we need to inform make to not try
to parallelize any work on any of the cyclic dependencies, otherwise
multiple builds will execute building the same binary, and the result
will be truncated outputs.
For example, System's Makefile would launch all the parallel builds for
the dependencies:
$(secxml_libdir)/System.dll \
$(the_libdir_base)System.Xml.dll \
$(the_libdir_base)Mono.Security.dll \
$(bare_libdir)/System.dll
They could be launched in parallel, and in turn the makefiles on those
directories might try simultaneously to invoke recursively a component
that has not been built yet.
So we use .NOTPARALLEL to flag all the cyclic dependencies on a given
directory to instruct make to not run those in parallel.
This patch is a continuation of the previous work on System to remove
the multi-stage build configuration in Mono's class libraries and avoid
the overwriting of assemblies in a multi-stage build setup.
This patch introduces an infrastructure to stage the builds for the core
assemblies that have cyclic dependencies. This deals directly with
the following cycle:
System.dll requires:
System.Configuration.dll
Mono.Security.dll
System.Xml.dll
They all require System.dll to be built
System.Xml requires:
System.dll
System.Configuration.dll
System.Security.dll requires:
System.dll
Mono.Security.dll
System.Xml.dll
Principle
=========
The patch works by directing the build infrastructure to place
intermediate build steps on their own directory. For example the
first System.dll build that only takes a dependency in mscorlib.dll is
placed not under the final directory but on a subdirectory called
"bare".
The second time that System.dll is built (after Mono.Security and
System.Xml have been built) is placed on the "secxml" directory.
The third time is the final build, and that one ends in the profile
directory.
The same principle is applied to System.Xml.
Better Dependency Tracking
==========================
To handle the multiple stages, the new Makefiles for the various
parties involved in this loop are now able to build their
dependencies. This means that typing "make" on System.Security or
System.Xml or System will build all of the intermediate steps as
required, without needing the toplevel Makefile to perform multiple
build shots to incrementally build the result.
Bug fixes
=========
We must have regressed at some point the build of System.Xml as we
were only doing one build of it, one without System.Configuration
support. This patch introduces back the changes to build System.Xml
in two steps.
This patch fixes the setup where we end up rebuilding System.dll and
overwriting it two times as the build progresses as a side effect
(this is what required LIBRARY_USE_INTERMEDIATE_FILE).
Details
=======
library.make:
Introduces a new "the_libdir_base" which is the raw directory
where the final output will go. This points to the same location
that libdir_base previously pointed to.
The existing libdir_base is modified to contain an optional
"intermediate" directory, where intermediate builds can be
placed.
Other cycles
============
The System.Design assembly was listed as having cycles, but while this
cycle exists in theory, in practice we have not implemented any of the
code that brings the cycle in System.Windows.Forms.Design's
ImageListImageEditor and chances are, we wont any time soon.
Less common case - unless the API difference has a large delta.
Some additional spacing is added to ease readability: if an entry takes two line then it needs a empty line.
All uses of the mono_dont_free_global_codeman variable (including its
definition) have been removed in
4a1ae4694a.
Its declaration should be removed as well to keep the codebase clean.
* The existing regex was not always used (e.g. new sections);
* It's now possible to use a regex on 'removed' (not just added) elements;
* It's possible to use the same regex for both (or have different ones);
counters_init is called at the end of runtime initialization, on runtime_initialized hook
counters_sample is called in the helper_thread at least once per second
Add new function mono_counters_register_with_size which let the counters API now what is going to be the max size of the string.
The type of the value passed when MONO_COUNTER_STRING is passed must be char* (instead of char** previously). This is to guarantee that, if we want to change the value of the counter, we do not reallocate and free the old value, but we change the value in place. Thus to avoir race condition and access to freed memory.
This is useful when the files needs to be pre-processed (e.g. a major change between the assemblies internals) and where some duplicate entries might be created (e.g. merged types/namespaces).
Note: normally the mono-api* tools should not produce such files (so it's better not used unless required)
After discussion with Kumpera, it was decided to load them lazily when calling mono_counters_foreach for the first time. It has to be inside the mono runtime, and not in a profiler because it accesses proclib API which is all MONO_INTERNAL functions.
The tarjan-coloring bridge is significant departure from the old bridge. It's design is based
on the Tarjan Strongly Connected Component algorithm.
SCC links are calculated as part of the Tarjan dfs on the second scan to calculate the low index and
form the components.
The algorithm does inspect all children after they have been processed, which enables us to do backward
propagation of the reachable SCCs.
In order to avoid the xref mess of the old algorithm, we color each component based on the sum of all
reachable components (colors). This means no matter how many non-bridge objects are in between two bridges,
they will all receive the same color and be represented in the final output as a single node in the SCC
graph.
This allows for a reasonably compact output graph as it will only include colors with no bridges when
a single object has multiple bridges reachable.
Said that, the basic algorithm received a series of optimizations:
1)Flag based merging, great idea from Mark, it bounds color and xref merging to be linear on the number of
colors found.
2)Objects and Colors bucket allocation. Instead of using expansible arrays we use fixed size buckets that
form a linked list. This allow us to use direct pointers instead of indexes. It avoid the expensive expansions.
Another benefit is that it reduces the work by sgen's malloc, which can be really slow.
3)Replace the object hash table with header patching. We tag objects with both pinning and forwarded bits and
store a pointer in the lock word. This eliminates the hashtable, a big source of perf issues. Patching objects
back at the end of bridge processing is much much cheaper than free'ing all the hashtable entries.
4)Color deduplication. It's possible to produce duplicated colors due to mutually unreachable paths that
both points to the same set of bridges. A cache is introduced to reduce it for colors points to 2 or 3 others.
The way we build colors allow us in the future to fix the hub object problem (SetupDoubleFan).
Experimental results with sgen-bridge-pathologies shows this implementation been 2-3x faster than the new one.
If currentCell still has a value when we call Columns.Clear() we
might try to end the editing. Because the columns got disposed
before calling Columns.Clear() we get a crash. This patch fixes
the problem by setting currentCell to null.
The tests require that the debug file is available, however in the net_4_0 profile this file isn't generated by default.
We now ensure the debug file is always generated for the test assembly.
This was previously used to not store counters that were not going to be dumped, but because we can now sample them, we have to make sure that they are stored, even if we do not plan to dump or sample them.
We can't forward to HashEntry's because they are volatile - the
hash table will resize, and the entries move. We need to point to
the objects, and then look them up via the hash. Also, we have
to forward chains of forwards.
Instead of merging the two lists by keeping them sorted, use the flag on
the SCCs the indicate whether an SCC has already been merged in, and
just append it if not. This makes it as fast as the new algorithm on one
test case where it was pathologically slow, while not exhibiting another
pathology that the new algorithm has.
Tha previous behaviour of MONO_PATH for relative paths (that implied
using the paths as relative to the current directory when loading
assemblies) was not yet documented and led to some failures when
executing tests.
In order to fix the failures, a new behaviour has been introduced:
relative paths are resolved at launch time, so that the folders which
are examined when loading assemblies do not depend on the current path
of the program.
This patchset is released under the MIT license.
When MONO_PATH contains relative folders, they are meant as relative
from where the application is launched, not from the current directory
of each assembly load.
Fixes#19380.
metadata/threads.c: fix regression from the 695b17f8d5 change and
avoid useless memory allocation. Report thread name to the profiler at
thread startup if it was set before that.
profiler/decode.c: fix typo.
profiler/proflog.c: ensure we get a consistent first buffer header at runtime
initialization.
We now try and trigger assembly resolve events for referenced assemblies
in a way that is more compatible with the MS runtime behaviour. If that still
fails we continue falling back and looking in the same directory as the referencing
image as before to keep compatibility with code that relies on the previous mono
behaviour.
The assemblyresolve_event3.cs test that used to fail on the MS runtime has been fixed
so it works now with both engines.
bugzilla.xamarin.com bug reference: Bug 19304
ComboBox reverts to original selection when it loses focus.
The LostFocus handler for the internal ComboTextBox class
was being called after it had been disposed. The dispose
was correctly called when the ComboBoxStyle changed from
it's initial default value to DropDownList. However, when
the ComboBox control lost focus later on, the LostFocus event handler
was called, which resulted in the Text value for the ComboBox
being overwritten by the value in the disposed object.
Could not see how to write a unit test within the ComboBoxTest.cs
that would simulate losing focus so only providing fix.
Change-Id: I9ca4cc75da5711a7d7c1dd166d5f52d580f44df1
The previous behavior when using mono_counters_dump was to pass -1 as the section and get all
counters dumped. This commit restore this behavior.
In addition to that, we want to enable callers to filter by variance as non monotonic counters are not useful
to be dumped at shutdown. To do so you just OR the variance with the sections you want. So what the runtime wants is:
mono_counters_dump (MONO_COUNTER_SECTION_MASK | MONO_COUNTER_MONOTONIC, stdout);
Dump all counters that are monotonic. Perfect.
Finally, to make the above neat, a reorg of the type bitfield was needed. Variance is now using a bit per kind.
Variance and unit where shrunk to 4 bits each, to open space for more sections.
This is more portable than using the mono_arch_instrument_* functions and
thus isn't prone to nasty arch-specific bugs. In particular, the old way
of instrumenting function prologues/epilogues resulted in a somewhat elusive
stack corruption bug on Android (ARM). Eventually, we should get rid of these
functions entirely and only use icalls, with JIT opcodes for special cases
(such as saving arguments for --trace).
This new way of doing things also makes profiler instrumentation AOT-safe,
since we're now going through the proper channels to emit references to the
runtime functions (mono_profiler_method_enter/leave) and to embed MonoMethod
pointers.
Since we're using icalls without wrappers to do this, there should be no
visible performance impact from this commit.
- Expanded monodoc-ecma schema to support the 'preserve-mono' attribute, and the attribution tag.
- Added preserve-mono to several pieces of documentation that we would like to preserve across future automated documentation imports: CipherSuitesCallback, ServicePointManager, CultureInfo, Environment+SpecialFolder.xml
- XSL template changes for monodoc HTML generation to support <attribution>
This patch builds upon commit 96a8500795 which placed parts of Mono.Security
responsible for dealing with SSL/TLS certificates for the purpose of certificate verification. The code enables
validation of the certifcates even if the user does not provide their own validation callback. The changes as related to
the original commit are few, basically consisting of enabling the same code used by MonoTouch in the MonoDroid context with
the only actual code change being the certificate validation bit mentioned above.
Since the change involves adding a subset of Mono.Security files to the monodroid version of System.dll, it is
also necessary to remove Mono.Android's dependence on Mono.Security.dll. The reason is that the code in AndroidPlatform
which looks up TLS support methods in Mono.Android.dll would use a type (X509CertificateCollection) that is now part of
System.dll but is *also* in Mono.Security.dll referenced by Mono.Android.dll and therefore the lookup would fail since
we'd have two distinct types from the reflection point of view.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=18962
This reverts commit 8f09dad435.
8f09dad435 is reverting a merge commit,
which will not do what you think it does. It will revert much more,
so revert the revert to get back the unintentionally reverted commits.
It looks like the next commit (1a15d4ec54)
is doing the original intention (reverting 164f9cbec4),
so this revert will leave the tree in a good state, with no pending
reverts.
Some types are statically known to never lead to a bridge. Objects like
string or int[]. By filtering them out very early in dfs1 we save memory by
not inserting them into the hashtable and reduce work done by all further steps.
The bridge implementation can be picked by having bridge-implementation=old|new in
MONO_GC_PARAMS.
This commit just prepared the ground to land experimental improvements to the bridge
while retaining an working implementation by default.
When the xbuild_12 profile is verified, the corlib from the net_4_5
profile should be in the MONO_PATH, otherwise the verification will
fail with:
The assembly mscorlib.dll was not found or could not be loaded.
It should have been installed in the `.../mono/4.5/mscorlib.dll' directory.
The adjustment rule must take into account that DST can start in the previous year and extend to some initial period
of the DateTime's year. This patch makes the code take that into account and correctly applies the DST offset to the
date being converted to some target timezone.
Fixes xambug https://bugzilla.xamarin.com/show_bug.cgi?id=17155
* ConvertTime (DateTime, TimeZoneInfo) now correctly takes the date kind from the DateTime parameter
and uses it to select the source time zone according to this criteria:
if DateTime kind is Utc, use TimeZoneInfo.Utc as source, in all other cases use TimeZoneInfo.Local
* Move argument checks in ConvertTime (DateTime, TimeZoneInfo, TimeZoneInfo) so that there's no risk of a NREX
should sourceTimeZone be null.
Added relevant tests for all of the above changes.
Otherwise this happens:
MCS [monotouch] Mono.CSharp.dll
../../mcs/codegen.cs(294,7): error CS1061: Type `System.Reflection.Emit.ILGenerator' does not contain
a definition for `BeginExceptFilterBlock' and no extension method `BeginExceptFilterBlock' of
type `System.Reflection.Emit.ILGenerator' could be found. Are you missing an assembly reference?
The runtime category is for high level counters on runtime operations.
Things like number of threads, threadpool status, total memory consumption
and so on.
The system category is for synthetic counters that report system values
such as RSS, user time and load.
This fixes the TableLayoutPanel implementation to check for control names
as well as the the controls themselves in looking up the row and column
values.
The height we calculate is the inner height, so we need to add the top
and bottom borders when setting the height of the listbox. The width
however is the outer width so we need to subtract the left and right
borders when setting the client width.
Vertically centered text on buttons didn't show up centered. The
referenced bug reports it on Windows. Matters were worse on Linux.
This patch tries to fix the problem on both Windows and Linux. On Linux
the positioning is improved although probably still not perfect.
This fixes Novell bug #463149
(https://bugzilla.novell.com/show_bug.cgi?id=463149).
When setting both Row.Height and MinimumHeight we need to set the
MinimumHeight first otherwise we will get a crash if the new Height
value is less than the old MinimumHeight value.
This change adds unit tests that demonstrate the bug #2394
where setting Row.Height below MinumumHeight in a DataGridView
doesn't work as expected. The unit tests also document the
behavior of .NET which isn't documented in MSDN.
When the MinimumHeight gets changed to a value less than Height
we set height to the new minimum height (and fire the
DataGridView.RowMinimumHeightChanged event). This matches the
behavior on .NET.
When the user tries to set Height to a value less than MinimumHeight
we silently set the height to the minimum height (instead of
throwing an exception). This matches also the behavior on .NET.
- fix the tests (tests made partially wrong assumptions which didn't
match the behavior of .NET).
- split MinimumHeight test in multiple smaller tests that test only
one thing.
- add a few more tests for MinimumHeight and Row.
Previously some characters might have been concatenated on a message
box that displayed an icon because the size of the text area was
calculated wrong. This fixes bug #2090
(https://bugzilla.xamarin.com/show_bug.cgi?id=2090).
The test tried to resolve an assembly from the GAC, which doesn't work on a
clean machine without an existing Mono installation.
We now check if the GAC directory is missing and ignore the test in that case.
2014-02-25 21:21:10 +01:00
7810 changed files with 878769 additions and 243580 deletions
for counter in 1 2 3 4 5 ; do if test -f $(topdir)/../msvc/scripts/inputs/$$config_file ; then config_file=`basename $(LIBRARY) .dll`-$(PROFILE)-$$counter.input; fi ; done ;\
Loaded 100 of 7810 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.