* Avoid following invalid pointers in mono_w32process_get_modules on Darwin.
`_dyld_get_image_name` and `_dyld_get_image_header` can return pointers
to data that will be freed or unmapped by concurrent calls to `dlclose`.
Avoid this by using `_dyld_register_func_for_add_image` and
`_dyld_register_func_for_remove_image` to install callbacks that
maintain a runtime-internal set of loaded dynamic libraries.
Some notes:
- dyld doesn't provide a public "app store friendly" API (like
`dl_iterate_phdr`) to traverse a snapshot of all loaded dynamic
libraries in a process. There are two alternative private APIs that do
this: one uses `_dyld_process_info_create` and friends and is present in
macOS 10.12 and above, and the other depends on
`_dyld_get_all_image_infos`, which is documented by Apple (... in a WWDC
video) to "go away" at some point in dyld3.
- `dladdr` linearly scans the dyld loaded image array (and each image's
segment set) for a matching address, so `image_added` will get slower as
more dynamic libraries are loaded in the process. But dyld3's
implementation of dlopen already scales linearly in time with the number
of loaded libraries. The use of `dladdr` can be avoided by using
`_dyld_register_for_image_loads` or
`_dyld_register_for_bulk_image_loads`, but those are both private APIs.
- The callbacks registered with `_dyld_register_func_for_add_image` and
`_dyld_register_func_for_remove_image` can never be unregistered, so
this is yet another thing that makes it impossible to safely unload an
embedded mono.
- `MonoW32ProcessModule::inode` only seems to be used to avoid dupicates
in other implementations of w32process; sorting the returned module list
in `mono_w32process_get_modules` wouldn't be necessary if the
`mono_dyld_image_info`s were also kept in an intrusive circular doubly
linked list.
- It looks like `mono_w32process_get_modules` in `w32process-unix-bsd.c`
has a similar race condition.
Also see: https://github.com/mono/mono/issues/20107
* Formatting.
* Make `image_added` and `image_removed` non-blocking.
It is theoretically possible for `mono_w32process_get_modules` to cause
a deadlock if either `image_added` or `image_removed` is waiting for the
image table mutex to be released and if `g_new0`, `g_strdup`,
`g_hash_table_iter_next`, or any of the symbols they depend on are
lazily bound and haven't already been resolved.
Only one thread may iterate over the image table and only one thread may
add/remove entries to/from the image table.
The writer thread attemps to lock a mutex to block readers from
iterating over the table. If the writer successfully acquires this lock,
then no readers are concurrently iterating over the image table and it
is safe to eagerly free stale data.
If the writer doesn't successfully acquire this lock, then the reader
thread is running concurrently with the writer; if this happens, the
writer pushes stale data into a limbo list. Readers opportunistically
clear this list.
Use `mono_mutex_t` instead of `MonoCoopMutex`. Hand-roll the necessary
GC state transitions inside `mono_w32process_get_modules`.
Add `mono_conc_hashtable_foreach_snapshot` to mono-conc-hashtable.{h,c}.
`MonoConcurrentHashTable` depends on the hazard pointer table
(`hazard_table` inside hazard-pointer.c), which is initialized lazily on
the first call to `mono_thread_small_id_alloc`. Perhaps this should be
explicitly initialized early during `mono_init_internal`.
* Revert "Make `image_added` and `image_removed` non-blocking."
This reverts commit a22a4440df5f0f13da29b1b90e80a3420223c2b9.
* Use mono_mutex_t instead of MonoCoopMutex
* Explicitly load symbols not used by `image_added` before `mono_w32process_get_modules` runs
Co-authored-by: Imran Hameed <[email protected]>
Bumps bockbuild to get the changes from https://github.com/mono/bockbuild/pull/162
BigSur's CoreGraphics seems to need a copy of the data to stick around longer than the surface,
so we provide it a copy of the data instead.
* Revert "Revert "Emit DWARF debug_abbrev offset for compile units as a label instead of 0 (#19794)" (#20013)"
This reverts commit 83105ba224.
* Bring back previous debug_abbrev offset behavior on Apple platforms (#20031)
https://github.com/mono/mono/pull/19794 broke on iOS. Analyzing the result showed that, while the assembly was generated as expected, the linked result was different. Analyzing the LLVM code (which triggered the original fix) seems to imply that, on Apple platforms, they will not generate a label for it, only doing the 0-offset as we were doing before. Therefore, match the LLVM behavior by bringing back our previous logic when targetting Mach, otherwise use the new way of doing things.
Fixes https://github.com/mono/mono/issues/8806 (again)
(cherry picked from commit 51dfcfe5c0)
Co-authored-by: mathieubourgeois <[email protected]>
When we call a delegate that was bound to a specific function, don't do a virtual call.
Fixesmono/mono#19964
Co-authored-by: lambdageek <[email protected]>
With this change, `mono_post_native_crash_handler` chains the crashing signal directly, instead of that having to happen after `mono_handle_native_crash` returns (which created a fragile repetitive code pattern). Finally, this way `mono_post_native_crash_handler` can also re-raise the signal right after chaining it. Since we remove our crashing signal handlers in `mono_handle_native_crash`, this should allow the OS to handle the signal as the final action.
Fixes https://github.com/mono/mono/issues/19860
* [merp] Add API methods for getting hashcode/reason of last crash
* Add test
* Review feedback and cleanup
Co-authored-by: Alexis Christoforides <[email protected]>
When outputting DWARF code to start a compilation unit in .debug_info, the standard expect a 4-byte offset from the .debug_abbrev code. Mono has always output an offset of 0.
However, this doesn't work in every cases. When we have linux+fullaot, we link two object files (one from Mono, one from LLVM). Both have their .debug_abbrev section. If we use 0 as an offset, it seems possible that the linker will keep thinking that our offset is 0, no matter the circumstances. Since the offset is always 0, it can be using the wrong abbreviation table (i.e. the one from the LLVM assembly instead of the one from the Mono assembly). The consequence of this is that the linked file is not valid DWARF (dwarfdump and objdump will complain about invalid offsets). At best, some tools will be able to work with a part of what we have, but any program requiring entirely valid DWARF will fail.
To fix this, we generate a label for the start of our debug_abbrev section and we instead generate it by generating a long with that label. This matches existing behavior seen in the LLVM generated code, and makes dwarfdump and objdump react properly to the linked product.
Fixes https://github.com/mono/mono/issues/8806
Co-authored-by: Mathieu Bourgeois <[email protected]>
`Xamarin.Android` native runtime calls `mono_reflection_type_from_name`
and passes `NULL` as the `image` parameter. The parameter is then
propagated all the way to `_mono_reflection_get_type_from_info` where,
in case the assembly isn't loaded yet, it is used to obtain base
directory of the assembly. However, since the `image` parameter is
`NULL` in our case, attempt to dereference it causes a segfault:
libc : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x4c0 in tid 11029 (ompanyname.app3), pid 11029 (ompanyname.app3)
crash_dump64: obtaining output fd from tombstoned, type: kDebuggerdTombstone
/system/bin/tombstoned: received crash request for pid 11029
crash_dump64: performing dump of process 11029 (target tid = 11029)
DEBUG : *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
DEBUG : Build fingerprint: 'google/sdk_gphone_x86_64/generic_x86_64:10/QSR1.190920.001/5891938:user/release-keys'
DEBUG : Revision: '0'
DEBUG : ABI: 'x86_64'
DEBUG : Timestamp: 2020-05-25 14:45:29+0200
DEBUG : pid: 11029, tid: 11029, name: ompanyname.app3 >>> com.companyname.app3 <<<
DEBUG : uid: 10134
DEBUG : signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x4c0
DEBUG : Cause: null pointer dereference
DEBUG : rax 000000000000002f rbx 0000000000000001 rcx 0000000000000000 rdx 0000000000000030
DEBUG : r8 0000000000000003 r9 000000000013e2e2 r10 0173eed800000000 r11 0000000000000206
DEBUG : r12 0000000000000000 r13 00007478530343c0 r14 00007478075eda33 r15 000074780763efb0
DEBUG : rdi 0000000000000000 rsi 00007478e2cb14d0
DEBUG : rbp 00007ffef3a35680 rsp 00007ffef3a355d0 rip 0000747807a4066a
DEBUG :
DEBUG : backtrace:
DEBUG : #00 pc 00000000003ba66a /data/app/com.companyname.app3-aQUF6Ge6_v-WaLb5i8Q7vw==/lib/x86_64/libmonosgen-2.0.so (_mono_reflection_get_type_from_info+474)
DEBUG : #01 pc 00000000003ba3d1 /data/app/com.companyname.app3-aQUF6Ge6_v-WaLb5i8Q7vw==/lib/x86_64/libmonosgen-2.0.so (mono_reflection_type_from_name_checked+321)
DEBUG : #02 pc 00000000003ba26d /data/app/com.companyname.app3-aQUF6Ge6_v-WaLb5i8Q7vw==/lib/x86_64/libmonosgen-2.0.so (mono_reflection_type_from_name+125)
DEBUG : #03 pc 000000000000ddb5 /data/app/com.companyname.app3-aQUF6Ge6_v-WaLb5i8Q7vw==/lib/x86_64/libmonodroid.so (xamarin::android::internal::EmbeddedAssemblies::typemap_java_to_managed(char const*)+389) (BuildId: 9952f1cfe0d910ae631abc73479f88eef34fd71d)
DEBUG : #04 pc 000000000000def3 /data/app/com.companyname.app3-aQUF6Ge6_v-WaLb5i8Q7vw==/lib/x86_64/libmonodroid.so (xamarin::android::internal::EmbeddedAssemblies::typemap_java_to_managed(_MonoString*)+99) (BuildId: 9952f1cfe0d910ae631abc73479f88eef34fd71d)
DEBUG : #05 pc 0000000000069532 <anonymous:5ad25000>
Even though this happens in `Xamarin.Android`, the error may occur for
any embedding application which passes `NULL` for the `image` parameter
in situation when the assembly isn't in memory yet.
Co-authored-by: Marek Habersack <[email protected]>
Fixed#10435
HttpListener already closes the Response object, closes the HTTP Client connection, and then sets the value of Response.StatusCode again. If so, an ObjectDisposedException is thrown.
```
Unhandled Exception:
System.ObjectDisposedException: Cannot access a disposed object.
Object name: 'System.Net.HttpListenerResponse'.
at System.Net.HttpListenerResponse.set_ContentLength64 (System.Int64 value) [0x00013] in <b4473693dd3c4d45883c574a53529fbe>:0
at MonoConsoleApp1.Program.Main (System.String[] args) [0x000f8] in <a66f6d7d417445dc9f89c691941ca70b>:0
at MonoConsoleApp1.Program.<Main> (System.String[] args) [0x0000c] in <a66f6d7d417445dc9f89c691941ca70b>:0
[ERROR] FATAL UNHANDLED EXCEPTION: System.ObjectDisposedException: Cannot access a disposed object.
Object name: 'System.Net.HttpListenerResponse'.
at System.Net.HttpListenerResponse.set_ContentLength64 (System.Int64 value) [0x00013] in <b4473693dd3c4d45883c574a53529fbe>:0
at MonoConsoleApp1.Program.Main (System.String[] args) [0x000f8] in <a66f6d7d417445dc9f89c691941ca70b>:0
at MonoConsoleApp1.Program.<Main> (System.String[] args) [0x0000c] in <a66f6d7d417445dc9f89c691941ca70b>:0
```
If an error is sent to the HTTP client while processing a request, it is patched so that the next process is not executed anymore.
Backport of #19664.
Remove the assert because we don't need to stop the debug if we cannot create the object when calling the constructor using invoke_method, if it's a DebuggerTypeProxy, we are not able to show the value of the DebuggerTypeProxy, but we still can show the Raw View, if it's not the case of DebuggerTypeProxy, we just cannot evaluate this expression, but we can continue the debug session.
Fix#19492
Backport of #19542.
* Add BeginRead/BeginWrite/EndRead/EndWrite overloads back to SslStream and underlying implementation. Unlike the default implementation in Stream it allows parallel read along with parallel write using the standard TaskToApm pattern (https://github.com/dotnet/runtime/issues/33447). This reverts part of https://github.com/mono/mono/pull/17393 which could lead to deadlocks as reported in https://github.com/mono/mono/issues/18865.
* Move the TaskToApm pattern from MobileAuthenticatedStream to SslStream
* Bump API snapshot submodule
Co-authored-by: Filip Navara <[email protected]>
* Backporting this, and after this I will backport the bump protocol for this PR.
* Bump API snapshot submodule
Co-authored-by: monojenkins <[email protected]>
This is needed by Xamarin.Android to be able to round-trip with names fetched via reflection, as the only public API for this (`mono_type_get_name`) uses the IL format instead.
Fixes https://github.com/mono/mono/issues/19377
Co-authored-by: CoffeeFlux <[email protected]>
Cygwin now ships libssl 1.1 which removed OpenSSL_add_all_ciphers so the xar configure fails.
Replace the configure check with another existing function to fix it.
(cherry picked from commit e10990125d)
* Use GArray instead of GList when getting custom attributes from an image
Xamarin.Forms calls this _constantly_ during startup, to the point where the malloc calls were actually showing up in the profile. This should help with that, and gives us some ms back during startup.
There are also a bunch of calls that return empty arrays, which in theory could be created in managed for a perf boost. However, it seems the Xamarin.Android team has mostly gotten rid of those calls and that optimization would complicate the code and require changes to our managed CustomAttribute implemented for both legacy and netcore, so I've opted to not check it in for now. If the empty calls continue to show up down the line, I can dig the code back up from my local branch and PR it separately.
If this is producing huge arrays and malloc continues to show up in the profile, consider https://github.com/dotnet/runtime/issues/32972. Even without that, this is a substantial improvement.
* [metadata] Fix leak in custom attribute lookup (#19279)
https://github.com/dotnet/runtime/commit/9dec6ae2ea81d46884bf49d2df8b26cc1e28eb12#r37604565
Co-authored-by: CoffeeFlux <[email protected]>
(cherry picked from commit 9f390a7d8a)
Co-authored-by: CoffeeFlux <[email protected]>
* The problem was a parent class overriding an interface that was already override by another interface. Fix#18917
* Adding test to cmake.
* Fixing test.
* Fixing test.
* Trying to refactor mono_class_setup_vtable_general.
* Changing what was suggested by @lambdageek.
* Update mono/metadata/class-init.c
Co-Authored-By: Aleksey Kliger (λgeek) <[email protected]>
* Update mono/metadata/class-init.c
Co-Authored-By: Aleksey Kliger (λgeek) <[email protected]>
Co-authored-by: Thays Grazia <[email protected]>
Co-authored-by: Aleksey Kliger (λgeek) <[email protected]>
There was a race where a domain was being unloaded while debugger would access it. A domain was only removed from the 'appdomains_list' as a very last step. The domain was already invalid to access at this point (locks freed for example).
Worse, images would be unloaded if only referenced by that domain. All places the debugger iterates domains hold the loader lock. The loader lock is acquired by the domain unloading process, so as long as a domain is not unloading when we access it inside of the loader lock we are safe.
include domain unloading check in collect_domain_bp
Co-authored-by: Jonathan Chambers <[email protected]>
* [corlib] Suppress finalization of underlying console FileStreams
We already suppress the finalization of the CStreamReader and CStreamWriter,
but during shutdown, the underlying FileStream may be finalized which
invalidates its access field which can lead to a crash.
The issue is that during shutdown, the CStreamWriter and its underlying
FileStream might be finalized in arbitrary order, so if the FileStream is
finalized first, even though it doesn't own the safeHandle, the access check in
Write(byte[], int, int) will fail, despite the fact that the underlying call to
MonoIO.Write could have succeeded.
Addresses https://github.com/mono/mono/issues/19005
Co-authored-by: Aleksey Kliger <[email protected]>
All these functions are MONO_RT_EXTERNAL_ONLY and they all allocate managed
objects.
Fixes a deadlock if an embedder calls the function and it needs to take the GC
lock to do a collection.
Co-authored-by: lambdageek <[email protected]>
* [corlib] Capture the ExceptionDispatchInfo when rethrowing from TaskContinuation
In `task.GetAwaiter().OnCompleted(action)` if `action` throws, the
`TaskContinuation.RunOrScheduleAction method will catch the exception and then
call `RuntimeAugments.ReportUnhandledException`. We must not simply throw the
exception again - in that case we will lose all the frames leading up to the
`catch` in `RunOrScheduleAction`. Instead use ExceptionDispatchInfo to
caputure the original throw.
Addresses https://github.com/mono/mono/issues/19166
* [test] Add regression test
For annoying reasons we can't run this as a simple NUnit test because the
exception is unhandled on some arbitrary threadpool worker thread, and those
don't show up within an NUnit setup.
Additionally because the unhandled exception in the root domain would normally
terminate the application, we need to run this in a new appdomain.
Co-authored-by: Aleksey Kliger <[email protected]>
Followup to https://github.com/mono/mono/pull/19126 and
https://github.com/mono/mono/pull/19169.
Bring arm64 `mono_arch_get_call_target` in line with other platforms by
returning NULL on failure instead of asserting. Bits 30-26 in an arm64
unconditional branch are exactly 0b00101, so 0x1f (0b11111) is used as a
mask to determine if the branch uses an immediate target--0x7 (0b111)
would incorrectly match against branches using register targets. The
extracted immediate is now sign extended in a branch-free way.
Avoid following blx entries in the method address table; ld64 can emit 4
different instruction sequences for islands involving thumb, and I'd
rather not implement support for them all now because 32-bit iOS is old
and large unlinked assemblies seem rare.
Co-authored-by: Imran Hameed <[email protected]>
[2020-02][arm][ios] Follow branch islands when determining method entry addresses.
Fixes https://github.com/mono/mono/issues/18612; `aot_code_low_addr` and
`aot_code_high_addr` were set to a range that included only first-level
branch islands, so `find_aot_module` would fail early when passed a
genuine function address.
This change only affects monotouch for now.
Why not use relative offsets stored in a read-only section? One reason
is that llvm-as cannot handle a `.long` directive containing a
subtraction expression involving externally-defined symbols. The AOT
method address table and AOT LLVM-generated code are currently emitted
in separate object files, so the method address table would include
expressions with undefined symbols.
Related: https://xamarin.github.io/bugzilla-archives/70/707/bug.html
Backport of #19126.
For example, the system name of a signal ('segv') or 'MANAGED_EXCEPTION' are typical arguments.
Co-authored-by: Alexis Christoforides <[email protected]>
* [runtime] Improve handling crashing signals
The default handlers for SIGTRAP, SIGSYS on macOS and Linux crash the process, so we now have Mono report this.
This patch also changes how the name of the signal is acquired for passing on to the crash reporting functions, allowing code reuse on crashing signals.
* [mono] Remove SIGTRAP handler, as it interferes with debugging
See https://github.com/mono/mono/pull/18243#issuecomment-586013427
* Fix lack of cleanup for SIGSYS
[2020-02] [aot] Avoid `mono_defaults` when creating trampolines.
Fixes https://github.com/mono/mono/issues/19009.
https://github.com/mono/mono/pull/18505 made PLT initialization occur at
image load time. When initializing the PLT for mscorlib,
`mono_defaults.corlib` is not yet initialized.
This change works around this by using `mscorlib_aot_module`--which is
initialized relatively early--instead of `mono_defaults.corlib`. PLT
initialization is also moved slightly later: it now happens after
`use_page_trampolines` has been initialized. The `USE_PAGE_TRAMPOLINES`
macro has also been changed to dereference `mscorlib_aot_module`.
This commit also removes an unused parameter from
`mono_aot_create_specific_trampoline`.
Backport of #19055.
/cc @lewurm @imhameed
This fixes https://github.com/mono/mono/issues/17140; intermittent incorrect results from GetTotalBytesAllocated for current thread. uint64_t and a pointer difference are not the same type/width on all architectures, so incorrect results can happen with out the parenthesis.
Co-authored-by: Nathan Ricci <[email protected]>
This is needed because the required='false' field in
```
<type fullname="System.Reflection.Emit.TypeBuilder" required='false' preserve="fields" feature="sre">
<method name="SetCharSet" feature="sre" />
<!-- reflection.c mono_reflection_call_is_assignable_to () -->
<method name="IsAssignableTo" feature="sre" />
```
Fails to preserve the IsAssignableTo method.
Co-authored-by: Fan Yang <[email protected]>
* [merp] Capture Environment.FailFast message in crash report
* [test] merp-crash-test refactor crasher data; add optional validator
Switch from a Tuple<T1,T2> to a struct for the crash items. Add a third
optional validator field which is an action to run on the json blob that we get
back.
Not updating existing tests to do any json validation, yet.
* [test] Add new MERP crash test for Environment.FailFast
Check that the resulting json blob includes the failfast message.
* Make MonoWebRequestHandler linker friendly
* Make MonoWebRequestHandler's ctor public (to be able to use in Activator.CreateInstance without binding flags)
* Remove Console.WriteLine from system.net.http
Co-authored-by: Egor Bogatov <[email protected]>
[2020-02] [sdks] add anroid-interpreter-{arm64-v8a,armeabi-v7a,x86,x86_64} targets
The Xamarin.Android team prefers that we ship two different `libmonosgen-2.0.so` for each target, e.g. for arm64 we will have with this PR:
* `./sdks/out/android-arm64-v8a-release/lib/libmonosgen-2.0.so`
* `./sdks/out/android-interpreter-arm64-v8a-release/lib/libmonosgen-2.0.so`
As the names indicate one has the interpreter enabled.
This is contrary to what we do for Xamarin.iOS. There, `--enable-minimal=interpreter` has the side-effect that the build will produce a `libmono-ee-interp.dylib` that can be linked next to `libmonosgen-2.0.dylib`. We _could_ do the same for Android, but that would require us to
* Add `--disable-visibility-hidden` to the Android Mono runtime builds. There are concerns however that this will slow down `dlopen (libmonosgen-2.0.so)` on the Xamarin.Android side.
* Do some changes to the interpreter infrastructure, because `--disable-minimal=interpreter` is designed to be used with a cross compiler in mind. For example, we would need a different solution for this: https://github.com/mono/mono/blob/d7e6fcbda82639fd5afe106b0e7a65a2a72a4f63/mono/mini/tramp-arm64.c#L631-L634
/cc @grendello
Backport of #18814.
/cc @lewurm
* Bump linker submodule
* Use -o instead of -out for linker output
The arguments changed in linker.
Co-authored-by: Fan Yang <[email protected]>
Co-authored-by: Alexander Köplinger <[email protected]>
Backporting this since we see errors during `pip install` on the Android Mono SDKs build on Linux and with this we're removing the call to pip (it wasn't needed).
Backport of #18783.
Co-authored-by: Alexander Köplinger <[email protected]>
* [2020-02] Bump msbuild to track xplat-master
* Bump roslyn to 3.5.0-beta3-20111-03
* * Update nuget.exe to match msbuild
- the closest version available right now, to `5.5.0-rtm.6422` is
`5.5.0-preview2`, so using that for now.
Update the nunitlite submodule to pick up some fixes in the NUnit v3
outputwriter that are needed by xamarin-macios.
Co-authored-by: Manuel de la Pena <[email protected]>
Use of `access_token` is now deprecated, switching to HTTP header
```
Please use the Authorization HTTP header instead, as using the `access_token` query parameter is deprecated.
```
(cherry picked from commit 2f74ab393f)
[interp] Remove goto for code_type unknown | interp | compiled.
[interp] Remove goto for code_type unknown | interp | compiled.
The goto kinda implies a loop, but it is really just handling one case
before the other, but the source misorders the checks, perhaps for perf,
which maybe, can be done equivalently with G_UNLIKELY, and also remove
some possible extra memory reads.
[interp][wasm]Use per-call recursive functions in interpreter to aid debugging.
When the interpreter does recurse, use a different function
for each call site, so you can tell from a WebAssembly stack
which case it is. i.e. with function names but no line numbers.
With this, we can see that call_varargs contributes to the problem
here: https://github.com/mono/mono/issues/18646
Also, do not inline the interpreter, it probably/hopefully never was.
* [mini] Add optional method name to --stats (#18387)
* Implement parsing for optional method name to --stats command line argument.
* Implement parsing for optional method name to --stats command line argument.
Co-authored-by: Kyle Markland <[email protected]>
Co-authored-by: Rene Garcia <[email protected]>
* Respond to PR feedback.
* Refactored away helper functions.
* Refactored counter setup into separate function. Moved stats optional method into its own condition.
Co-authored-by: Kyle Markland <[email protected]>
Co-authored-by: Rene Garcia <[email protected]>
* Renamed mono_setup_counters->mono_enable_counters. Restore whitespace to 0a51d89c42
Co-authored-by: Kyle Markland <[email protected]>
Co-authored-by: Rene Garcia <[email protected]>
* [mini] Print header for stats. (#18442)
* Add an enum for dumping stats at points in time. Print header before dumping stats in mini_cleanup.
* Make print_stats_header private.
* Remove unused variable.
* Refactored print_stats_header to better accomodate optional methods for stats
* Change printf calls to g_printf in response to feedback.
* Undo changes in response to @CoffeeFlux 's feedback. Add g_printf calls to mini_cleanup
* Avoid always printing stats at shutdown.
* Condition on `mono_stats` instead of `mono_jit_stats`.
* [mini] Global JIT Stats Printing (#18483)
* Make print_jit_stats global to enable interp and JIT-triggered stat dumps.
* Rename some functions for consistency.
* Add a comment to clarify the necessary locking in different contexts.
* Rename mono_print_jit_stats to mono_runtime_print_stats and make it more generic.
* Rename runtime_cleanup_stats back to jit_stats_cleanup.
* Fix a line that was indented with spaces.
* [mini] parse fully qualified method name using mono_method_desc_new (#18499)
* Make print_jit_stats global to enable interp and JIT-triggered stat dumps.
* Rename some functions for consistency.
* Add a comment to clarify the necessary locking in different contexts.
* Use MonoMethodDesc struct and associated helpers to parse from command
line args. Remove unused stats_method_name and setter function.
Squashed commit of the following:
commit de7410696dab10723c76f545076522daa17e85d1
Author: Rene Garcia <[email protected]>
Date: Thu Jan 16 23:01:23 2020 -0500
Utilize new stats printing function.
commit 1e5038adfec06c670dbaced771a8ff9344502d17
Author: Rene Garcia <[email protected]>
Date: Thu Jan 16 22:37:53 2020 -0500
Remove unused stats_method_name and setter function. Use mono_method_desc_full_match instead of mono_method_desc_match.
commit 04f86c66c139e064bc35738f955f960232eb6cbb
Author: Rene Garcia <[email protected]>
Date: Thu Jan 16 18:11:37 2020 -0500
Modify mono_method_desc_match to actually match namespace and class. Add global MonoMethodDesc, and parse it from command line args. Leave TODO print statement in mono_jit_compile_method_inner.
* Move mono_method_desc to mini-runtime header. Fix whitespace.
* Cherry pick @KyleMarkland 's changes, and resolve merge conflicts.
* Fix leak. Give better error message when parsing empty method name.
* Move freeing of mono_stats_method_desc.
Co-authored-by: KyleMarkland <[email protected]>
* Add a conditional to transform.c to enable stat dumping from the interpreter. (#18540)
* [mini] Use g_printerr instead of g_printf before exiting (#18574)
* Rename g_printf -> g_print
* Use g_printerr on errors instead of g_printf.
* Pass NULL to mono_counters_dump. Revert g_printf to g_print.
* Update manpage
* Feedback
Co-authored-by: rgarc <[email protected]>
Co-authored-by: KyleMarkland <[email protected]>
I fear this causing packaging problems, but as-is we require Python 3 for most of our Python files but don't actually check for that in configure. We should be consistent about this. Some projects (notably wasm) also use the Python version detected here, so bumping this will also bump the version used in those cases (a good thing, since there are some known bugs when using the scripts with Python 2).
The original fix back at #18554 did not work quite right, which was missed for lack of CI.
Reworked this check to instead test for `-mminimal-toc` on all powerpc hosts, and to only do the ELF version check on FreeBSD.
Fixes#18554#18578 current CI build failures on AIX
* [aot] Handle '|' during symbol mangling.
* [aot] Clean up the construction of the linker command line.
* [aot] Pass -Wl,-install_name to the linker on osx, otherwise the shared object will be named based on the output file name i.e. <assembly>.dylib.tmp.
* [llvm] Pass the MonoAotFileInfo pointer to the init functions, not used yet.
* [jit] Add support for direct calls between methods in different AOT images in LLVM mode.
* Add a 'direct-extern-calls' AOT option.
* Initialize the PLT/GOT during method initialization,
this normally happens in load_method () but that is
not called when a method is directly called.
* Add self initialization support for JITted methods, they can be
called directly since they are fallbacks if LLVM fails.
* Fix the build.
* Avoid calling BeginInvoke etc. directly, its implemented by the runtime.
* Unify some cases.
* Init PLT at image load time since directly called methods without initializers might make calls through it.
* Fix a startup problem.
* Make the mono_is_corlib_image () check for during startup.
* Check for is_inited in the init icall wrappers, since they might be called from JITted code which doesn't check it.
* Address review comments.
When calling a generic class we need to make sure it has been inited.
This is done by calling generic_class_init. Since this call happens
frequently, but will only run once, it should be put out of line, assisting
branch predictor, preventing misspredictions (in all places but the first).
Currently this is not the case, since we will generate code like this:
0000000000000484: cmp byte ptr [rcx+2Dh],0
0000000000000488: jne 000000000000048F
000000000000048A: call p_3_plt_EmptyGame__jit_icall_mono_generic_class_init_llvm
000000000000048F: mov rax,qword ptr [mono_aot_EmptyGame_llvm_got+0C8h]
Where we will always (except for first call) take the forward branch.
Instead we should mark the call to the method as out of line, at least
giving the code generator the information so it can move it out of line
and preventing a jmp, unless when it needs to init, the slow path. Doing
that will generate the following code:
0000000000000484: cmp byte ptr [rcx+2Dh],0
0000000000000488: je 00000000000004C1
000000000000048A: mov rax,qword ptr [mono_aot_EmptyGame_llvm_got+0C8h]
...
00000000000004C1: call p_3_plt_EmptyGame__jit_icall_mono_generic_class_init_llvm
00000000000004C6: jmp 000000000000048A
decode_patch_info () would not decode patches if their corresponding GOT entry
was already set, causing half initialized MonoJumpInfo entries to be returned
to callers. Set the type of the MonoJumpInfo entry to MONO_PATCH_INFO_NONE
in these cases, and have the callers handle it.
Co-authored-by: Zoltan Varga <[email protected]>
When stepping out of a c# breakpoint into the runtime (or JS... Not sure if that's accurate),
multiple single step requests can be created when the breakpoint is hit again. In order to handle this scenario for wasm,
we just cancel the existing one.
NOTE: The debugger args addition seemed a better way to handle this than outright canceling in debugger-engine. If there
are implications to doing this, I can take it out.
Use -j with all example make invocations, mention Ninja dependency, mention raising ulimit, recommend py3 for running the server (when using py2, the port isn't properly released).
* [merp] MONO_DEBUG=no-gdb-stacktrace shouldn't disable MERP
Only prevent `gdb` or `lldb` from being invoked.
MERP is controlled by separate mechanisms --- configure flags for crash
reporting and an explicit opt-in icall.
The existing code collects crashed process data in-process, but it writes the
data out (using mono_merp_invoke) in the forked child process. This is a bit
surprising, but in the interest of not disturbing the code too much, this PR
doesn't change that. We should revisit `dump_native_stacktrace` again in the
future and rationalize these decisions.
Addresses https://github.com/mono/mono/issues/18565
* [interp] Enable virtual calls to compiled code
If we have an aot-ed version of a method we should always go through it, because the IL for that method could be stripped.
* [interp] Disable jit call for wrappers
Some generic wrappers don't seem to work in mixed mode, probably due to the fact that the transition already reuses a gshared wrapper.
Assume we have the following form `MyForm`:
```
using System;
using System.Drawing;
using System.Windows.Forms;
namespace test_TreeView
{
public class MyForm : Form
{
TreeView treeView = new TreeView()
public MyForm()
{
treeView.Nodes.Add("root node");
treeView.Nodes[0].Nodes.Add("first child node");
treeView.BackColor = Color.Gray;
treeView.LineColor = Color.Yellow;
treeView.DrawMode = TreeViewDrawMode.OwnerDrawText;
treeView.DrawNode += treeView_DrawNode;
Controls.Add(treeView);
}
private void treeView_DrawNode(object sender, DrawTreeNodeEventArgs e)
{
var brush = new SolidBrush(Color.FromArgb(100, 255, 0, 0));
e.Graphics.FillRectangle(brush, e.Bounds);
}
}
}
```
The displayed result is

One can see couple drawing issues:
* White rectangles under each `TreeNode`.
* The area of custom drawing (red rectangles) is shifted with respect to this white rectangles.
Current PR proposes the fix of this issues.
Co-authored-by: monojenkins <[email protected]>
* Fix Return handling. Ensure correct ClientSize.
When pressing Return / Enter, ensure any target button is both visible
and enabled.
In CreateHandle(), ensure the ClientSize is correct if set. If not,
update it to make it right. Suspend layout while changing it so that
child controls with anchors other than Top Left are not moved.
* Select active control. PerformLayout after updating for client size.
Select the active control with SendControlFocus to avoid upsetting what
is currently selected.
* Improve Form window decoration adjustment handling
Reverts the incorrect attempted fix contained in previous commits.
Basically, when a property is changed that affects window decorations,
ensure the client size stays the same.
* Use UpdateFormStyles on FormBorderStyle too.
When the user types a letter or digit, KeySearch looks for and selects
an item starting with that character. However, it should not if
SelectionMode is None.
* [WinForms] Make `ContextMenuStrip` behavior closer to the reference one
* Bump API snapshot submodule
Co-authored-by: monojenkins <[email protected]>
I've implemented a heap of missing RTF and RichTextBox stuff, and also made some improvements or fixes to various aspects of it. I'm sorry this is so big...
To give an overview of the changes, here's a list:
- Removed the RTF Charcode / Charset handling that wasn't actually used, had a lot of missing functionality and was basically reimplementing character encoding handling, and replaced it with ensuring the correct character encoding is being used (changing when needed).
- Improved RTF handling of objects with object results (process the given object result). Sometimes pictures can be like this.
- Improved line wrapping and alignment
- Added or greatly improved support for:
- paragraph spacing
- line spacing
- paragraph indents (left, right, hanging)
- tabstops (left, centre, right, decimal)
- text background colour (like highlighting)
- superscript / subscript
- character offset (vertical)
- text visibility
- Significantly improved RichTextBox RTF generation
- Cache DPI, rather than doing `CreateGraphics()` every time it is needed
- A variety of other fixes and improvements, with a few I can think of relating to:
- caret position
- replacing text
- invalidation and drawing
- when tags are added or deleted
BreakpointRequest commands can come out of order and before the runtime is ready (RuntimeReady). A null check for the DebugStore was added to guard against this since these requests seem to be for JS breakpoints. These seem to be able to be safely ignored.
Fixes https://github.com/mono/mono/issues/18584
Current versions of the mono return a null pointer as address of the first
element for empty arrays, i.e.
fixed (byte* ptr = new byte[0]) Console.WriteLine (ptr == null);
will print "true". This causes a problem in the UnixEncoding class where it
triggers a check for null pointers. Fix this by allowing null pointers when
the number of elements is zero.
Whenever mono opens an X11 window, the application opens a tcp socket for controlling the (non-tcp)-connection to X11. This is bad practice, as a tcp socket is not needed.
This pull request cleans the logic, by replacing the tcp socket with a fifo. That way this loopback connection is not visible from outside the .NET application, and all logic surrounding it should remain unchanged.
The real change here is, in `XplatUIX11.SetWindowPos()`, simply moving the `SendMessage` call to the end instead of earlier. The problem with it earlier is that any change in bounds from any of the bounds-related events (OnLocationChanged / OnMove, OnSizeChanged / OnResize, OnLayout, OnClientSizeChanged) will be overridden. When `SendMessage` is called, `UpdateBounds` is run, and that raises those events as relevant. After those events finish, `SetWindowPos` continues with setting the size of the window to the value originally specified – which is now potentially wrong. So send the message later on.
There is also no point that I can see in writing the values to `hwnd` twice, because as far as I can see the only one that can be changed is `hwnd.ClientRect` (set by `PerformNCCalc`).
Fixes#18524
The `tt.xml` and `tt_RU.xml` files were added in CLDR 34: http://cldr.unicode.org/index/downloads/cldr-34
Upgrading to v34 (or the latest v36) introduced a larger number of new cultures. I went with the smallest change possible to have Tatar added.
Fixes#18554 by making autoconf actually check if `-mminimal-toc` works instead of assuming on powerpc. Tested with FreeBSD 12.x and 13.x on powerpc64 ELFv2.
While we are in here, also enable BTLS which has passed testing.
* Validate the address that came from IDE using PointerValue. The IDE can send an invalid address and it was crashing mono.
Fixes#18191Fixes#15612
Co-authored-by: Aleksey Kliger (λgeek) <[email protected]>
* [wasm] Fix netcore build.
Add a DOTNET_REPO_DIR variable to Make.config which should point to the dotnet/runtime repo. Compile
the netcore runtime and corelib from this repo.
* Disable wasm+netcore on CI.
compile-runtime-tests is looking for python3, but $(env python3) will return error (no `/usr/local/bin/python3`); if this is the case, create a symlink from 3.6 or 3.7 to /usr/local/bin/python3 so it works. We already have this listed in `SHEBANG_FILES` for the port.
Found more occurrences of the typos in dotnet/runtime#2061
The work done here is made by simple search & replace.
I'll point to replaces that needs attention in a review.
Co-authored-by: Youssef Victor <[email protected]>
- roslyn's shared compiler server hashes it's pipename on the path to
the assembly.
- On macOS, this looks like `/Library/Frameworks/Mono.framework/Versions/6.8.0/lib/mono/msbuild/Current/bin/Roslyn/VBCSCompiler.exe`
- When installing a new mono, with that same `x.y.z` version, this
process will effectively be out of sync with the new updated
mono/msbuild/roslyn
- This manifests as:
```
Using shared compilation with compiler from directory: /Library/Frameworks/Mono.framework/Versions/6.8.0/lib/mono/msbuild/Current/bin/Roslyn
/Library/Frameworks/Mono.framework/Versions/6.8.0/lib/mono/msbuild/Current/bin/Roslyn/Microsoft.CSharp.Core.targets(59,5): error : Roslyn compiler server reports different hash version than build task. [/Users/builder/azdo/_work/3/s/xamarin-android/build-tools/xaprepare/xaprepare/xaprepare.csproj]
```
- See https://github.com/xamarin/xamarin-android/pull/4108
- So, we kill any running roslyn shared compiler servers
* If a thread was suspended and doesn't have any managed stack, it was considered as terminated, but it wasn't really terminated because it can execute managed code again, and stop in a breakpoint so if the execution arrives in debugger_agent_breakpoint_from_context we reset the flag terminated to FALSE.
* Adding terminated = FALSE in single_step_from_context.
This causes an additional dependency of mono on libintl which we didn't have before.
Reported by a user on gitter, it's problematic on macOS since it makes the mono binary depend on the libintl we ship in the Mono .pkg.
It was introduced in Mono 6.6 by https://github.com/mono/mono/commit/18e0ebfe89be0a175d2f904b9bb1ec6816daa318
[prof] remove wrong cast for format string
Fixes this warning:
```
CC mprof-report.o
mprof-report.c:408:62: warning: format specifies type 'char *' but the argument has type 'guint64' (aka 'unsigned long long') [-Wformat]
snprintf (format, sizeof (format), "%s : %%" PRIu64 "\n", (guint64)key_format);
~~ ^~~~~~~~~~~~~~~~~~~
%llu
/Applications/Xcode112.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/secure/_stdio.h:57:62: note: expanded from macro
'snprintf'
__builtin___snprintf_chk (str, len, 0, __darwin_obsz(str), __VA_ARGS__)
^~~~~~~~~~~
```
mistake in refactoring commit https://github.com/mono/mono/commit/07402062541fa9555bef99dbaac84cfb587926cd#diff-c825627ea9ddb3fa753fa3617eaec7c8R408
* [aot] fix warnings on linux (gcc 8.3.0)
Fixes these warnings:
```
aot-compiler.c: In function ‘emit_trampolines’:
aot-compiler.c:7675:28: warning: ‘_e’ directive writing 2 bytes into a region of size between 1 and 256 [-Wformat-overflow=]
sprintf (end_symbol, "%s_e", symbol);
^~
aot-compiler.c:7675:4: note: ‘sprintf’ output between 3 and 258 bytes into a destination of size 256
sprintf (end_symbol, "%s_e", symbol);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
At top level:
aot-compiler.c:753:1: warning: ‘link_shared_library’ defined but not used [-Wunused-function]
link_shared_library (MonoAotCompile *acfg)
^~~~~~~~~~~~~~~~~~~
aot-compiler.c:558:1: warning: ‘mangle_symbol_alloc’ defined but not used [-Wunused-function]
mangle_symbol_alloc (const char * symbol)
^~~~~~~~~~~~~~~~~~~
aot-compiler.c:535:1: warning: ‘mangle_symbol’ defined but not used [-Wunused-function]
mangle_symbol (const char * symbol, char * mangled_symbol, gsize length)
^~~~~~~~~~~~~~~~~~~
```
* [amd64] fix warnings on linux (gcc 8.3.0)
Fixes this warning:
```
tramp-amd64.c: In function ‘mono_arch_create_generic_trampoline’:
tramp-amd64.c:242:65: warning: variable ‘ex_offset’ set but not used [-Wunused-but-set-variable]
int i, lmf_offset, offset, res_offset, arg_offset, rax_offset, ex_offset, tramp_offset, ctx_offset, saved_regs_offset;
^~~~~~~~~
```
* [lldb] fix warnings on linux (gcc 8.3.0)
Fixes these warnings:
```
lldb.c:243:1: warning: ‘buffer_add_buffer’ defined but not used [-Wunused-function]
buffer_add_buffer (Buffer *buf, Buffer *data)
^~~~~~~~~~~~~~~~~
lldb.c:215:1: warning: ‘buffer_add_id’ defined but not used [-Wunused-function]
buffer_add_id (Buffer *buf, int id)
^~~~~~~~~~~~~
lldb.c:208:1: warning: ‘buffer_add_long’ defined but not used [-Wunused-function]
buffer_add_long (Buffer *buf, guint64 l)
^~~~~~~~~~~~~~~
lldb.c:188:1: warning: ‘buffer_add_short’ defined but not used [-Wunused-function]
buffer_add_short (Buffer *buf, guint32 val)
^~~~~~~~~~~~~~~~
```
* [interp] fix warnings on linux (gcc 8.3.0)
Fixes these warnings:
```
interp/interp.c:3425:1: warning: ‘g_error_xsx’ defined but not used [-Wunused-function]
g_error_xsx (const char *format, int x1, const char *s, int x2)
^~~~~~~~~~~
CC interp/libmono_ee_interp_la-mintops.lo
CC interp/libmono_ee_interp_la-transform.lo
CCLD libmono-ee-interp.la
ar: `u' modifier ignored since `D' is the default (see `U')
CC libmono_dbg_la-debugger-agent.lo
CC libmono_dbg_la-debugger-state-machine.lo
CC libmono_dbg_la-debugger-engine.lo
CCLD libmono-dbg.la
ar: `u' modifier ignored since `D' is the default (see `U')
CCLD mono-sgen
AR libmain.a
ar: `u' modifier ignored since `D' is the default (see `U')
CC interp/libmaintest_a-whitebox.o
In file included from interp/whitebox.c:3:
interp/transform.h:163:12: warning: ‘stack_type’ defined but not used [-Wunused-variable]
static int stack_type [] = {
^~~~~~~~~~
interp/transform.h:155:20: warning: ‘stack_type_string’ defined but not used [-Wunused-variable]
static const char *stack_type_string [] = { "I4", "I8", "R4", "R8", "O ", "VT", "MP", "F " };
^~~~~~~~~~~~~~~~~
```
* [thread state] fix warnings on linux (gcc 8.3.0)
Fixes these warnings:
```
CC libmonoutils_la-mono-threads-state-machine.lo
mono-threads-state-machine.c:33:1: warning: ‘get_thread_no_safepoints’ defined but not used [-Wunused-function]
get_thread_no_safepoints (int thread_state)
^~~~~~~~~~~~~~~~~~~~~~~~
mono-threads-state-machine.c:26:1: warning: ‘get_thread_suspend_count’ defined but not used [-Wunused-function]
get_thread_suspend_count (int thread_state)
^~~~~~~~~~~~~~~~~~~~~~~~
```
* [domain] fix warnings on linux (gcc 8.3.0)
Fixes these warnings:
```
appdomain.c:2415:1: warning: ‘get_app_context_base_directory’ defined but not used [-Wunused-function]
get_app_context_base_directory (MonoError *error)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CC libmonoruntimesgen_la-assembly-load-context.lo
CC libmonoruntimesgen_la-domain.lo
domain.c:135:1: warning: ‘mono_domain_alcs_lock’ declared ‘static’ but never defined [-Wunused-function]
mono_domain_alcs_lock (MonoDomain *domain);
^~~~~~~~~~~~~~~~~~~~~
domain.c:138:1: warning: ‘mono_domain_alcs_unlock’ declared ‘static’ but never defined [-Wunused-function]
mono_domain_alcs_unlock (MonoDomain *domain);
^~~~~~~~~~~~~~~~~~~~~~~
domain.c:2129:1: warning: ‘mono_alc_free’ defined but not used [-Wunused-function]
mono_alc_free (MonoAssemblyLoadContext *alc)
^~~~~~~~~~~~~
domain.c:2108:1: warning: ‘mono_domain_create_default_alc’ defined but not used [-Wunused-function]
mono_domain_create_default_alc (MonoDomain *domain)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
domain.c:2084:1: warning: ‘create_alc’ defined but not used [-Wunused-function]
create_alc (MonoDomain *domain, gboolean is_default)
^~~~~~~~~~
```
* [native library] fix warnings on linux (gcc 8.3.0)
Fixes this warning:
```
CC libmonoruntimesgen_la-native-library.lo
native-library.c:295:1: warning: ‘mono_loader_register_module_locking’ defined but not used [-Wunused-function]
mono_loader_register_module_locking (const char *name, MonoDl *module)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
* [sample] fix warnings on linux (gcc 8.3.0)
Fixes this warning:
```
CC libtestlib_la-test-mono-embed.lo
In file included from test-mono-embed.c:7:
../../samples/embed/teste.c:20:1: warning: function declaration isn’t a prototype [-Wstrict-prototypes]
gimme () {
^~~~~
```
* fix for checked builds
* [runtime] NOHANDLES for ves_icall_System_Threading_Thread_GetCurrentThread
This function (and its call to mono_handle_new) was showing up in the
flamegraph for some async-heavy benchmarks
HashTableTests.Ctor_Int_Int_GenerateNewPrime and BitConverterTests.ToString_ByteArrayTooLong_Throws allocate a lot of memory and this causes issues on Windows i386 and other platforms.
* Do not `printf` `long long` or `unsigned long long`.
*Do* printf `gint64` or `guint64`.
Do not printf %ll.
Do not printf %z.
gint64 == int64_t, which could be long, or long long, or maybe other
guint64 == uint64_t, ditto
For printing gint64/guint64, use PRId64, PRIx64, etc.
For printing gsize/gssize, use `G_GSIZE_FORMAT` (seems like excess `G`).
%z definitely would warn for every single use, with Mingw.
And %ll might also, since on 64bit platforms, gint64 tends to be
long, not long long, and would merit %l not %ll.
(No matter that %ll is merited on 32bit, and the behavior
would then be correct on both.).
If there becomes a system w/o PRId64 etc., and it is a 64bit system,
then we could use %l under a portable name.
Or %I64. This appears unlikely (unless reach is extended to older Windows runtime).
Note that PRIxPTR for gsize/intptr_t may be a good idea too.
CoreCLR has a managed cache surrounding this, but for the moment the naive implementation will suffice. We can later move their managed cache to shared on top of this PR with minimal trouble.
We can't guarantee the id will be [0..CpuCount) for a variety of reasons, and a followup PR to the dotnet docs will clarify this. I've chosen not to intentionally add an offset, but no one should be relying on that behavior, and if someone thinks adding an offset would drive the point home the perf cost is irrelevant.
* [sgen] Don't subtract twice the nursery size from max_heap_size
We were subtracting the nursery size when initializing max_heap_size as well as adding it to the allocated_heap when allocating the nursery (alloc_nursery).
* [sgen] Trigger collection if failing to allocate los section
If the memory governor says we are exceeding the max_heap_size by allocating a los section (1MB) for a new los object, attempt to clear some space by triggering a major collection, before completely bailing out.
There are pluses and minuses here:
+ Minimize externC.
+ Maximimze typesafe linkage.
- Minimize configuration-sensitivity.
- Maximize commonality across all configurations, so that
success in one configuration maximally but not 100% implies
success in others (which is why to avoid `#if` in general,
to contribute toward compilation success).
+ Use higher level macros to explain reason.
Even if ICALL_EXTERN_C was always externC (presently not),
using it instead of plain G_EXTERN_C offers a builtin comment.
Add mono_gc_thread_detach callback for Boehm
Use under Boehm to detach without threads lock as Boehm will take it's own lock internally.
Note in `on_gc_notification` we take threads lock after Boehm already has it's own lock. For consistency and to prevent deadlocks always take lock ordering of Boehm then threads lock.
* [cxx] dlmalloc remove extern "C" and remove NO_MALLINFO.
* [cxx] Move CallInst bitfields to the end to minimize padding for alignment
and fix an unexplained LLVM problem.
1. Update `build.sh` to use `--enable-checked-build=private_types` which forces the use of getter methods to access `MonoClass` fields.
2. Fix up some places that were accessing MonoClass directly.
3. Get rid of a spurious comma operator usage from an earlier refactoring:
```c
z = a, b, c;
```
is the same as
```c
z = a; b; c;
```
which is the same as just `z = a;` if `b` and `c` have no side-effects.
GroupBox's GetPreferredSize() is not great. I've simply copied the code from Panel, and used that. It uses LayoutEngine.GetPreferredSize(), which does things a lot better than the code this used.
Previously, if the Label wasn't quite high enough nothing would be drawn as the line didn't quite fit. It should draw the line anyway, clipped if necessary.
- Ignore key events with vkey == 0. They won't match a real key code so don't try. Besides, trying can cause segfaults on ChromeOS Linux mode.
- Check special-case keys (numpad) before looping to get them. No point leaving them for afterwards...
- Make the state of Control.CanSelect depend on whether the control is visible and enabled.
- When setting Control.Visible to false, if this control is focused, move the focus to the next control.
Fixes https://xamarin.github.io/bugzilla-archives/20/20233/bug.html
Previously, on Linux, setting Control.Region just set the clipping for painting, but didn't influence the visibility of other controls behind the one it was set on. This implements this correctly via X11 Shape extension.
Two small fixes to X11 keyboard handling here:
- For Xutf8LookupString, use the actual buffer size rather than the starting buffer size. Using the previous fixed size made the buffer overflow handing code immediately after the change pointless.
- For XLookupString, handle similar to Xutf8LookupString, getting a byte array. The old was sometimes causing problems where input on the numeric keypad didn't enter text. I believe using a StringBuilder similar to how it was _should_ work, but for some reason I could not get it to work reliably. So I changed it to this, which seems to work well for me. The only question I have is whether it should be Encoding.ASCII like I used, Encoding.Default, or another specific encoding.
- Use alternative names as a fallback if present.
- Use the untagged name (\fname, name that doesn't
identify charset ) if present.
- Use font codepage or charset correctly to get the correct encoding.
Rip out the old nonfunctional RTF charset handling.
This was not used, and furthermore was fundamentally flawed.
I have replaced it by simply using the correct text Encoding, mentioned
above.
CharCount / length was inconsistent about counting line endings. Fixed
to include them all, as that was much easier than the other way.
When shortening a wrapped line, it is necessary to start the recalculate
at the previous line, in case the wrap point has changed.
In CharIndexToLineTag, if there is a line boundary at the specified
index, return the line starting at the index.
Fixed a few other things too.
RTF paragraph controls override earlier instructions, rather than
keeping the maximum.
Emit \nosupersub between superscript and subscript text. Missing it out
technically gives a superscript (or subscript) of the subscript (or
superscript), which is not what we want.
rather than keeping the maximum.
* RTF.cs: Add support for JPEG and EMF pictures.
Allow for attribute etc. groups inside the picture group.
* Line.cs: In InsertString, ensure that the tag passed in is currently
in the line – not necessarily valid when the passed tag is the
cursor, for instance.
* LineTag.cs: Only break tags for formatting when needed.
* TextControl.cs: Fix invalidating text that isn't left-aligned.
Fix caret stuff:
Positioning after the line ending no longer happens
Up and down when not left-aligned
Tag used when moving left to start of line
Page up / down
Remove empty tags when navigating away from them
Change tag background draw location – I think it is a correction!
When inserting at a position without being given the tag, choose an
empty tag at that position if one exists.
Change ReplaceSelection order back (corrected some formatting and
similar stuff), and format the new text to match the tag.
Change IncrementLines to transverse the tree (using a new function)
rather than repeatedly call GetLine.
* RichTextBox.cs: Don't streamline the line in case it removes tags we
want to keep – we'll skip them ourselves instead.
Emit pictures.
* TextBoxBase.cs: Remove redundant check – a previous check means
value != acutal_border_style, therefore at least one of them !=
BorderStyle.Fixed3D, therefore the if condition was always true.
The dpi isn't likely to change during the lifetime of the object, so is relatively safe to cache.
Creating a Graphics object each time the dpi is wanted when reading RTF is also rather silly performance-wise.
Even worse, when generating RTF it can cause a recalc, which can mean that some lines <= end_line don't exist.
In GenerateRTF, check tag != null before trying to generate anything based on it. Not sure
why it hasn't been a problem before, but either way I was getting NullReferenceExceptions
because of it today.
Run ContentSizeChanged() when either width or height changes, irrespective of Multiline status.
This fixes various problems with stuff jumping around vertically.
Correct ContentSizeChanged to consider the left and right margins instead of the left margin twice.
Was probably a typo at an earlier stage, otherwise would have been a * 2.
* LineTag.cs: Added support for visibility. Corrected handling of tabs
and added tabstop support.
* RichTextBox.cs: Added support for text visibility, indents,
tabstops.
* TextControl.cs: Make invisible text work correctly. Fixed a bug with
tag backcolor. Added support for indents.
Native methods can be run in gc safe mode, meaning we can be in gc safe mode while setting/getting the arguments for a native transition. Call context computation requires us to be in unsafe mode.
Fixes https://github.com/mono/mono/issues/16969
[memory barrier] use pagesize determined by helper
`limits.h` doesn't always define `PAGESIZE` properly (e.g. iOS), so it would fall back to `0x1000` (4096) but it's really `0x4000` (16384) on iOS. We already have a helper in the runtime to determine the pagesize, so let's use that instead.
Fixes https://github.com/mono/mono/issues/18273
This was prompted by https://github.com/mono/mono/issues/18339, which seems to be failing to locate a native library and then hitting an assertion. We should propagate the error instead, so that if others run into something similar they can see what's actually going wrong instead of just getting a runtime crash.
The base image appears to have perl5.26 which conflicts with perl5-5.30, resulting in the /usr/local/bin/perl binary not being placed by perl5-5.30, which results in failed builds. The `perl5.26` appears to be part of the base image and has no packages actually dependent on it.
* [sgen] Include also derived classes as bridges
When using `MONO_GC_DEBUG=bridge=` debug option
* [sgen] Fix xref computation with tarjan bridge
Between C# and java (on android) there are objects that live on both worlds. This means that there exists a C# object with a corresponding java object. The relationship between them is strong, meaning if C# object is alive then java object must stay alive, and vice-versa. We keep java bridge objects always alive through a GCHandle (on the java gc). When doing a C# collection we select all bridge objects that appear to be dead on the C# side. These objects are candidates for collection, assuming the java side has nothing against it. Before triggering a collection on the java side (following the mono gc) we switch all the strong gchandles to the java objects to be weak (for these objects that are candidate to be collected) and we recreate the reference graph from the C# side to the java side (if C# Bridge1 can reference C# Bridge2 then, on the java side, we add a reference from Java Bridge1 to Java Bridge2; this is done by adding to an array of references inside Java Bridge1). In order to minimize the amount of work that needs to be done on the java side, we compute the minimal amount of references that need to be added, by computing the strongly connected components of the object graph.
An optimized way to construct the SCCs and the xrefs is by using the tarjan algorithm (https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm). Our algorithm is non recursive (scan_stack emulates the recursive order of traversal in a dfs algorithm, while loop_stack is the stack used by the algorithm). A color represents an SCC. We have some optimizations in place where we might merge colors if they don't contain bridges, since the client only cares about SCCs containing bridge objects and the links between them. color_merge_array is used to keep track of all neighbors of a node until we are creating the scc for that node. It is populated when scanning all the refs inside an object (compute_low). All the colors in the color_merge_array will be cross references with that scc.
Before this commit we were only clearing the color_merge_array when creating an SCC. This is problematic because we could end up with xrefs inside of an SCC that belong to another SCC. Consider the simple graph of nodes 0,1,2,3 where 0 <=> 2, 0->1, 2->3. Assume we start scanning with node 0. When creating the SCC for node 3 the followed path is 0 -> 2 -> 3, while the loop stack will contain (0,1,2,3). After creating SCC for node 3, we will finish scanning node 2 which would detect the xref to Bridge3, which would have been added to the color_merge_array. Because node 2 is not the root of the SCC it belongs to (its lowlink points towards node 0 which has a lower index), we are not creating an SCC with it, and the link to node 3 remains in color_merge_array. Because the next node from the scan_stack is node 1, which is also the root of the SCC that it belongs to, we will create an SCC for it and wrongly add the node 3 reference from color_merge_array to it. In order to fix this issue, we will always clear the color_merge_array once we finished scanning the xrefs for a node. If the node in question is not the root of an scc, then we will remember them as xrefs pointing out from this object. When we finally reach node 0 (which will be the root of the SCC containing nodes 0 and 2), we will then know that all xrefs for this color are the union of the xrefs of all objects belonging to this color (which represents the objects that we are popping from the loop_stack until we encounter the root node).
Even though this change adds required bookeeping for xrefs, I didn't notice any change in performance on the bridge tests that we have in mono/tests.
* [sgen] Some logging improvements in tarjan bridge
* [sgen] Disable optimization when comparing bridge outputs
When this optimization is enabled, the tarjan bridge will create more SCCs in order to reduce amount of xrefs in the graph. This would render the `bridge-compare-to` debug flag unusable with tarjan bridge.
* Set thread pool thread name just based on string pointer check.
When the generation-based solution went in, there were not
yet constant thread names, so a pointer based approach could fail
due to reuse. We can do slightly simpler now.
* Remove the generation field which is no longer needed.
Remove the duplicated knowledge of how to set a constant and put
it behind a funny sounding but perhaps reasonable flag.
Revise corlib version.
* Add SignedCms to the typeforwards in the System.Security.Cryptography.Pkcs facade
* Added additional missing types from System.Security.Cryptography.Pkcs.
* It would be nice if the files I added had namespaces ;-)
* Bump API snapshot submodule
* [csproj] Update project files
Co-authored-by: monojenkins <[email protected]>
Fixes https://github.com/mono/mono/issues/18323
* [System.Private.CoreLib] Cleanup intrinsic tracking
1. Removed icalls where intrinsic version for the method exists
2. Add [Intrinsic] attribute to methods which have runtime intrinsic
to make them easier to track and to tell linker not to analyze them
3. Use recursive syntax for any intrinsic which can be called via
reflection to correctly apply the intrinsic when invoked.
```c#
public static bool IsSupported { get => IsSupported; }
```
When one calls X86.IsSupported, the call gets replaced by an
intrinsics. When one calls it with an Invoke, the body of IsSupported
gets replaced by intrinsics. It's just a hack to get Invoke support for free.
* [interp] implement System.Type::op_Equality
* Undo changes which are not yet supported by interpreter
* [interp] Implement System.Runtime.CompilerServices.RuntimeHelpers::OffsetToStringData
Co-authored-by: Bernhard Urban-Forster <[email protected]>
* [jit] Avoid passing a vtable argument to DIM methods when making calls out of gsharedvt methods.
Fixes https://github.com/mono/mono/issues/18276.
* Fix compilation with mcs.
* [metadata] Size 0 Blob heap is ok when resolving assembly refs
Sometimes ILasm can produce images with a Blob heap of size 0. In cases where
we're loading assembly references from such an image, the hash (which is
optional) can be at index = 0 and the Blob heap size is also 0.
Also: add the hash value to the output of `monodis --assemblyref`
* [metadata] Add a separate assertion for the index == size == 0 case
And a comment explaining how it is likely to be triggered. If the assembly is
reasonable the caller of mono_metadata_blob_heap should be updated to use
mono_metadata_blob_heap_null_ok instead
* [bcl] Allow Mono's ILASM to produce a size 0 Blob heap
ECMA 335 II.24.2.4 says that the user string and blob heaps should have an
entry at index 0 consisting of the single byte 0. However .NET Framework (and
.NET Core) ilasm will entirely omit the Blob heap (that is, create a blob heap
entry of size 0) if it is not needed. This PR changes Mono's ILASM to emit the
initial byte on demand only if one of the MetaDataStream.Add() methods is
called. Otherwise we will also emit a stream of size 0.
This is needed to compile some test cases.
* [tests] Add regression test for loading assemblies with size 0 Blob heap
Depends on ILASM that can emit a size 0 Blob heap
* [loader] Rename assembly name check strictness flag
* [loader] Add predicate for assembly name matching on netcore
* [loader] Enable LoadInDefaultContext test
* Make mono_assembly_names_equal external, change flags in domain search
* Move ifdef inside mono_loader_get_strict_assembly_name_check
* Fix pedump
* No reason to make this external
* Feedback
-> throw in a async task with a try catch in the caller -> don't stop
-> throw in a new thread with a try catch in the caller -> stop
-> throw in the main thread without any try catch -> stop
Including a new test to test the fix of #17601.
Fixing #16588, create a while 1 to stops the program execution when an exception is thrown and no try catch is found and MONO_DEBUG=suspend-on-unhandled.
Fixes#17601Fixes#16588
Also when iterating over the runtimes, actually look at the current element,
not the first element.
Also mention the unsupported runtime version in the warning message when it is
passed to mono_init_internal.
Fixes https://github.com/mono/mono/issues/17916
They cannot deal with large test assemblies so we need to split them.
We're doing this by introducing a new `#skip <PROFILE>` directive in the .sources format which defines where to split the assembly.
The logic is very simple: files up until the first `#skip` are common files which get included in each part, subsequent files are only in the respective part assembly.
Fixes https://github.com/mono/mono/issues/18213
This assert fails when the trampoline code size worst case is realized.
Observed on a Android device with HWASan [1] enabled, where heap
addresses have a non-zero tag in the most significant byte, and thus
require 4 instructions to materialize in emit_imm64.
[1] https://source.android.com/devices/tech/debug/hwasan
Remove handles/MonoError from some marshal icall functions.
This does some small other things.
In particular, if a function is not static for some platforms, make it not static for all.
static historically was valuable, because of default linker semantics around visibility.
I believe it is less important now, since visibility is default constrained.
Also being consistent across platforms seems good.
Maybe split off a separate PR for that.
* [Wasm] Enable dynamic runtime tests
- Add dynamic runtime browser tests in CI
- Change `release-dynamic` to `dynamic-release` to align with other runtimes
- Add `-dynamic-runtime` flag for packager.exe
- Add debug configuration for dynamic runtime
- Fix invalid MAIN_MODULE=2 flag, which forces the emscripten linker to pass even on exported functions.
Fix locating Python interpreter when it isn't "python"
The "python" interpreter is specified by PEP-394. In it, an OS
can decide not to ship a "python" executable, and instead only
ship python2/3, providing some ambiguity for scripts that are
version-neutral, like the one Mono uses.
This uses an automake macro to locate a suitable Python, and
changes the makefile to use the located Python, whatever it may be.
A compiler barrier generates no code.
It "only" inhibits certain compiler optimizations, which I do not consider
particularly worrisome, as most code is "fully" optimized, and
compiler barriers are relatively rare.
It could be a concern in code paths that greatly benefit
from compiler optimizations and for which barriers greatly
inhibits the compiler.
I would further suggest, though it is not here, that any compiler
half barrier (read, write) be a compiler full barrier instead,
as they sound pretty cheap, so simplify.
Similar cannot be said about CPU barriers.
They do not always generate code, but when they do, it can cost.
This is follow-up from https://github.com/mono/mono/pull/17849#issuecomment-556273801https://github.com/mono/mono/pull/17849#issuecomment-557661604.
* [cominterop][test] Calling QueryInterface from an unattached thread asserts
If we pass a managed COM object to native code and the native code calls one of
the IUnknown methods, we assert because the thread is not attached but we want
to enter GC Unsafe mode.
* [cominterop] Attach to runtime from IUnkown and IDispatch methods
If the COM objects for a managed object is passed to a thread that hasn't
interacted with Mono before, we need to attach before doing GC thread state
transitions.
Addresses https://github.com/mono/mono/issues/18137
* [test] Call managed method through COM wrapper from unattached thread
This works, but I don't think we had a test previously. Call a managed method
via a COM interface from a thread that is not attached to the runtime, to
ensure that it is attached.
* Relax faultcode parsing for Soap11 message errors.
The mono implementation was reading the faultcode content as an XmlQualifiedName, which applied the rule where you could not
start a name with a number. This caused interoperability problems with the .net framework because their parsing just looks
for <namespace>:<name>, where name can be any string.
Example:
<faultcode>s:1</faultcode>
On mono, a soap response that contains a fault code name of 1 will throw an error. If you run the same code on the .net framework, it will not.
Fixes https://github.com/mono/mono/issues/12995
* [csproj] Update project files
* [wasm] Add linker substitutions in netcore mode.
* Enable non-netcore mode as well.
* Disable conditionals which are not true in threaded mode for now.
I don't remember why this wasn't enabled originally, but it seems to be passing now. I probably accidentally fixed it back when I made changes to our assembly name parsing.
Also partial undo recent and append _icall to end.
This is verbose, but maybe worthwhile to aid search.
This is extracted from https://github.com/mono/mono/pull/17978.
On Linux, neither flag being specified will result in a default of RTLD_LOCAL. Unfortunately, on MacOS it's the opposite - the default is RTLD_GLOBAL. This means currently there is no way to set RTLD_LOCAL on Macs, so despite the potential for this to break someone it directly contradicts our documentation and needs to be changed.
After https://github.com/mono/mono/pull/18040 we now have InternalsVisibleTo for the Mono.Android assembly.
This exposed the internal LogLevel enum in BCLDebug which causes an issue when consumed in XA:
```
Java.Lang/Object.cs(119,18): error CS0104: 'LogLevel' is an ambiguous reference between 'Android.Runtime.LogLevel' and 'System.LogLevel'
```
To fix this we rename the internal enum in corlib since it's not really used.
This can lead to problems on big endian.
```
result.i = (int) 1;
--> 0x0000_0001_XXXX_XXXX;
result.l = (long) 1;
--> 0x0000_0000_0000_0001;
```
On little endian it's always `0x0000_0000_0000_0001`, so it doesn't matter.
* [utils] Make mono_dl_open default to RTLD_LOCAL
The exception is for fallback handlers added via the embedding API, in which case we convert the flags over to preserve legacy behavior
* Convert flags properly for embedding API use
* Changes
* Turn off -fvisibility=hidden temporarily
TESTING
* Undo some previous crimes, maybe fix failure
* Leave legacy mono unchanged, defaulting to RTLD_GLOBAL
* [mini] Fix delegate trampoline virtual call via delgate Invoke
If we need to jit the Invoke method of a delegate, we get tramp_info with a
NULL method.
Background: normally when we create a delegate around a virtual method,
handle_delegate_ctor will just create a virtual invoke trampoline with
mono_arch_get_delegate_virtual_invoke_impl which doesn't get here. But if
we're asked to compile the delegate's Invoke method, then compile_special ()
will create a tramp_info with a null method, and return a delegate trampoline.
That's the case here - we had
var del = SomeDelegate(obj.VirtualMethod);
var invoke_method = del.GetType().GetMethod ("Invoke");
invoke_method.Invoke (del, args);
or
var del = SomeDelegate(obj.VirtualMethod);
var another_del = OtherDelegate (del.Invoke);
another_del (args);
in both cases, we end up in mono_delegate_trampoline with tramp_info->method ==
NULL.
in the second case the IL is like this:
newobj instance void Derived::'.ctor'
ldvirtftn instance void class Base::VirtualMethod()
newobj instance void class SomeDelegate::'.ctor'(object, native int)
So delegate->target is a derived instance but delegate->method is some base
class method.
Addresses https://github.com/mono/mono/issues/17718
* [tests] Add tests for compiling delegate's Invoke method
Where the delegate calls a virtual method
* [WinForms] Fix wrong behavior when calling ComboBox.Items.RemoteAt() with index equals to SelectedIndex
* [WinForms] Fix#10643 No event should be triggered when calling ComboBox.Items.RemoteAt()
Fixes#10643
Add the ability to initialize a `WebAssembly.Net.WebSockets::ClientWebSocket` from `System.Net.WebSockets.ClientWebSocket`.
`System.Net.WebSockets.ClientWebSocket` will delegate all calls to the WebAssembly ClientWebSocket.
- Add support for marshaling `Uri` class correctly. This was a cause of failures.
- Add bindings tests for `Uri` marhaling.
* Add some missing barriers when dealing with global caches
accessed from multiple threads without locks.
This is based on earlier PR https://github.com/mono/mono/pull/17849.
Read-side barriers are removed.
More analysis is needed to determine if they are needed (which pointer
read vs. written).
Write-side barriers are compiler barrier + store-release instead of full barrier.
Note all candidates are converted to new form yet.
Cases that do motivate read-wide barriers are skipped.
e.g.
`mono_arch_start_dyn_call`
`get_agent_domain_info`
`init_jit_info_dbg_attrs`
* PR: Remove 'Try one more time..'
* [utils] Add back mono_threads_attach_tools_thread
In https://github.com/mono/mono/commit/a5da7b21f4b6dbc5eaa09c2addee91b84dc1dbd5
we got rid of "tools" threads internally to the runtime.
However since the API was previously marked with MONO_API it was an internal
API that some embedders depended on.
This PR adds back an (external-only) limited form of tools thread.
The runtime is aware of the Tools thread in that FOREACH_THREAD_* macros will
iterate over them, and the thread has a coop thread state machine. (That is,
mono_thread_info_current() and GC Safe and GC Unsafe transitions all work.)
However the thread is:
1. Not stopped by the GC
2. Is not interrupted by profiler sampling.
3. Does not have a "current domain"
4. (As a consequence of the above) cannot call managed methods or touch managed
objects.
Such threads are useful for low-level interaction with the runtime such as
querying metadata, the JIT state and other coordination.
mono_threads_attach_tools_thread should be called no more than once. It should
not be called on a thread that is already attached with mono_thread_atach, and
vice versa.
Addresses https://github.com/mono/mono/issues/18011
* [threads] Make mono_threads_attach_tools_thread into a public API
[cxx] Remove use of register keyword.
https://jenkins.mono-project.com/job/test-mono-pull-request-wasm/19408/parsed_console/log_content.html
```
/mnt/jenkins/workspace/test-mono-pull-request-wasm/mono/utils/mono-md5.c:259:2: warning: 'register' storage class specifier is deprecated and incompatible with C++17 [-Wdeprecated-register]
register guint32 a, b, c, d;
^~~~~~~~~
/mnt/jenkins/workspace/test-mono-pull-request-wasm/mono/utils/mono-md5.c:259:2: warning: 'register' storage class specifier is deprecated and incompatible with C++17 [-Wdeprecated-register]
register guint32 a, b, c, d;
^~~~~~~~~
/mnt/jenkins/workspace/test-mono-pull-request-wasm/mono/utils/mono-md5.c:259:2: warning: 'register' storage class specifier is deprecated and incompatible with C++17 [-Wdeprecated-register]
register guint32 a, b, c, d;
^~~~~~~~~
/mnt/jenkins/workspace/test-mono-pull-request-wasm/mono/utils/mono-md5.c:259:2: warning: 'register' storage class specifier is deprecated and incompatible with C++17 [-Wdeprecated-register]
register guint32 a, b, c, d;
^~~~~~~~~
4 warnings generated.
```
Remove handles/MonoError from two socket icalls.
Ongoing removal of handles() icalls.
This is small, to pause and remove `mono_class_get_field_from_name_full` from w32socket.c.
* [netcore] Remove ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni and _len icalls.
They are implemented in C#.
The C# is equivalent to the C, and could be used for classic runtime, except for the treatment of large/negative lengths.
* Remove a few more icalls.
Instead of ifdef and leaving them uncompiled when compiling netcore,
declare them and put asserts in them.
* [amd64] align application stack pointer in signal handler
16byte stack pointer alignment is only required in certain places by the ABI, so the assumption that it holds all the time is wrong (though, it passed CI 😅). We have to setup the frame properly, i.e. we have to ensure the stack pointer is properly aligned. That's what we have done previously too.
Regression of https://github.com/mono/mono/pull/17922
Fixes https://github.com/mono/mono/issues/18006
* add ALIGN_DOWN_TO macro
* remove unnecessary ifndefs
Otherwise we'll run into issues because in configure.ac we update submodules _after_ we try to call external/bdwgc/configure (which won't be there if autogen.sh didn't run).
This would manifest itself as `*** No rule to make target 'all'.` in external/bdwgc when you build as there's no Makefile.
* [corlib] add InternalsVisibleTo for Mono.Android
Context: https://github.com/xamarin/xamarin-android/pull/3991
In Xamarin.Android, we have a bit of System.Reflection usage on
startup:
https://github.com/xamarin/xamarin-android/blob/bbbe2ed36e6eeb7cce0905dcbfdaeaa30754070f/src/Mono.Android/Android.Runtime/UncaughtExceptionHandler.cs#L47-L67
These methods are in `mscorlib.dll` and `internal`. If we had
`[assembly: InternalsVisibleTo ("Mono.Android")]` we could avoid the
System.Reflection.
This is already done for `Xamarin.iOS`, `Xamarin.Mac`, etc. so
hopefully it's OK to add one more?
We could then, just call these methods directly:
* `System.Diagnostics.Debugger.Mono_UnhandledException`
* `AppDomain.CurrentDomain.DoUnhandledException`
The results are possibly a 100-250ms improvement to startup:
Before:
12-03 14:27:51.450 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s727ms
12-03 14:27:57.310 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s723ms
12-03 14:28:03.216 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s703ms
12-03 14:28:09.054 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s679ms
12-03 14:28:14.953 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s711ms
After:
12-04 09:13:18.248 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s608ms
12-04 09:13:24.087 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s570ms
12-04 09:13:29.997 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s566ms
12-04 09:13:35.805 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s498ms
12-04 09:13:41.670 1876 1898 I ActivityManager: Displayed Xamarin.Forms_Performance_Integration/xamarin.forms.performance.integration.MainActivity: +3s475ms
This was the Xamarin.Forms integration project in xamarin-android.
Running a `Debug` build on a HAXM x86 emulator on Windows.
https://github.com/xamarin/xamarin-android/tree/master/tests/Xamarin.Forms-Performance-Integration
* Bump API snapshot submodule
* [wasm] Modify to use -s USE_ZLIB=1 instead of zlib support headers
- This will remove the dependency on the mono zlib header files.
- Moves the zlibtest.cs to tests/src directory to help clean up the main directory.
* [wasm][packager] Remove the zlib headers from the zlib build
- use `-s USE_ZLIB=1` instead when building.
* [android] don't probe directories for .config files
In Xamarin.Android, on startup we see logging like this for every .NET
assembly:
12-03 14:27:42.104 26842 26842 D Mono : Prepared to set up assembly 'FormsViewGroup' (/storage/emulated/0/Android/data/Xamarin.Forms_Performance_Integration/files/.__override__/FormsViewGroup.dll)
12-03 14:27:42.104 26842 26842 D Mono : Assembly FormsViewGroup[0xebcee9c0] added to domain RootDomain, ref_count=1
12-03 14:27:42.104 26842 26842 D Mono : Assembly Loader loaded assembly from location: '/storage/emulated/0/Android/data/Xamarin.Forms_Performance_Integration/files/.__override__/FormsViewGroup.dll'.
12-03 14:27:42.104 26842 26842 D Mono : Config attempting to parse: '/storage/emulated/0/Android/data/Xamarin.Forms_Performance_Integration/files/.__override__/FormsViewGroup.dll.config'.
12-03 14:27:42.104 26842 26842 D Mono : Config attempting to parse: '/Users/builder/jenkins/workspace/archive-mono/2019-10/android/release/sdks/out/android-x86-release/etc/mono/assemblies/FormsViewGroup/FormsViewGroup.config'.
In most cases, no `.dll.config` file exists and so it probes this
macOS-looking path:
/Users/builder/jenkins/workspace/archive-mono/2019-10/android/release/sdks/out/android-x86-release/etc/mono/assemblies/FormsViewGroup/FormsViewGroup.config
It looks like this is happening because nothing in Xamarin.Android
calls `mono_set_dirs` or `mono_set_config_dir` and so it falls back to
using `MONO_CFG_DIR`. `MONO_CFG_DIR` is set to a path on the build
machine.
Even if Xamarin.Android *did* call `mono_set_config_dir`, the code
appends `mono/assemblies`:
cfg = g_build_filename (cfg_dir, "mono", "assemblies", aname, cfg_name, (const char*)NULL);
So it doesn't seem useful to use this fallback at all, there would
never be a file found.
I wrapped the appropriate code in `#ifndef TARGET_ANDROID` blocks.
I was able to see a minor *maybe* ~20ms performance improvement on
startup:
Before:
12-03 14:27:48.494 26903 26903 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:601::443900
12-03 14:27:54.356 26963 26963 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:587::495400
12-03 14:28:00.263 27021 27021 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:586::147100
12-03 14:28:06.135 27074 27074 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:593::639100
12-03 14:28:11.988 27129 27129 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:571::194900
After:
12-03 14:46:50.590 27737 27737 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:503::918700
12-03 14:46:56.517 27794 27794 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:570::533600
12-03 14:47:02.368 27850 27850 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:537::435000
12-03 14:47:08.289 27904 27904 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:587::830900
12-03 14:47:14.130 27965 27965 I monodroid-timing: Runtime.init: end, total time; elapsed: 0s:555::593400
This was the Xamarin.Forms integration project in xamarin-android.
Running a `Debug` build on a HAXM x86 emulator on Windows.
https://github.com/xamarin/xamarin-android/tree/master/tests/Xamarin.Forms-Performance-Integration
* Add --enable-minimal=cfgdir_config
* This also defines `DISABLE_CFGDIR_CONFIG`
* Used this setting for android
* Added Obsolete to AppDomain.CreateDomain for monodroid. The intent is to be helpful for when .NET 5 comes along
* Changed AssemblyLoadContext link to a better doc
* Bump API snapshot submodule
Fix security identifier parsing error with the following SDDL:
```
O:S-1-5-21-1356517589-3987021482-2501375073-1001G:S-1-5-21-1356517589-3987021482-2501375073-513D:(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;S-1-5-21-1356517589-3987021482-2501375073-1001)
```
Allocation of thread objects usese the mono_object_new_mature API. These objects are allocated before the thread is finished attaching to the runtime. This means that a collection can happen on an unattached thread as well as all its callbacks, which is a counter-intuitive behavior.
On android this is problematic because at the end of the SGen collection we need to call the java collection, which needs to have the thread attached. This could probably be fixed instead from the Xamarin.Android side, but this approach seems simpler and saner.
Fixes https://github.com/mono/mono/issues/17878
* [WinForms] Fix#17980 Prevent from crashing when DataGridView is null.
Reproducer:
DataGridViewLinkColumn links = new DataGridViewLinkColumn();
links.UseColumnTextForLinkValue = true;
* [WinForms] Fix#17980 The field useColumnTextForLinkValue of DataGridViewLinkCell was not cloned.
* [WinForms] Fix#17980 the Text property was not set for every cell in the column when UseColumnTextForLinkValue is true
Fixes#17980
The only difference in the copies, was that one had an infinite timeout
so implied TRUE result unless interrupted.
Where the other copy had a timeout and could return FALSE as a result.
They both used the same underlying, with timeout, so it wasn't really an optimization,
just duplicated code.
Also there is subtelty around having a return value or an out parameter.
That is carefully preserved.
Also, coop is fixed, by creating a frame only in a slow path.
Presumably creating a thread is quick and stateless enough such that this
is not too late.
Hangs runtime; prevents CI from completing run. (Another test can
also hang the runtime, but is hard to reproduce and inconsistent
about that.)
This should be fixed eventually, but...
* [jit] Implement beginnings of SIMD support for WASM.
* [wasm] Add a DISABLE_WASM_NO_NETCORE Make.local conditional to disable non-netcore builds during development.
* [wasm] Add a --simd argument to the packager.
* Remove some duplicate defines.
* Fix an windows assertion.
[interp] track valuetype stack for CEE_RET too
Usually the stack depth is determined via basic block predecessors, but that only works for forward branches.
Fixes https://github.com/mono/mono/issues/17924
* [wasm] Handle more exceptions in the xunit runner.
* [wasm] Add more corefx test suites.
* Add more icall signatures.
* Add support for running the System.Compression test suites.
use `objdump` arguments to reduce verbosity (no raw bytes, etc) and make the dasm more diff-friendly.
On Linux all functions have a random prefix (address) - replace it with `0xD1FFAB1E` constant). On macOS it's fine by default.
Also, allow to generate diffs for a single assembly via `dump-asm-lib` rule.
There is a race condition on Safari as a result of using TaskCompletionSource that causes a stack exceeded error being thrown during Blazor startup.
Safari throws the following error:
```
[Error] Unhandled Promise Rejection: RangeError: Maximum call stack size exceeded.
step (blazor.webassembly.js:2530)
fulfilled (blazor.webassembly.js:2500)
promiseReactionJob
```
- Modify `WebAssemblyHttpMessageHandler.cs` to create the TaskCompletionSource to run continuations asynchronously.
- `TaskCompletionSource<HttpResponseMessage>(TaskCreationOptions.RunContinuationsAsynchronously);`
- There is a second part to this on AspNetCore in `Renderer.cs` to process it's pending startup tasks to run continuations asynchronously to compliment the TaskCompetionSource of the Http response message.
The following link discusses the potential stack/race problem that can occur when using TaskCompletionSource: https://devblogs.microsoft.com/premier-developer/the-danger-of-taskcompletionsourcet-class/
This is optional.
The real problem was -enable-cxx not actually compiling some files as C++.
This is still reasonable, to ward off the danger of that occuring again.
If `byte[] data` has additional data at the end `Decode` will try to parse it and will generate incorrect tags or throw an exception. This fix makes `Decode` to use only `nLength` bytes from `byte[] data`.
[threadpool] Decrement max_working when worker times out
The corresponding code in CoreCLR:
https://github.com/dotnet/runtime/blob/bf88f146412d1e2d41779422337184a802f186c9/src/coreclr/src/vm/win32threadpool.cpp#L2156-L2164
The issue is that counter._.max_working is only ever changed by:
1. the monitor_thread when it detects starvation (increment by 1).
2. the hill climbing algorithm (increment or decrement).
Creating a periodic load of creating many workers at once followed by a minute
or more of quiescence increases the variable worker.counters._.max_working in
monitor_thread(). Once that counter matches worker.limit_worker_max,
monitor_thread() keeps looping without unparking or creating a thread, even
though the actual number of threads/workers is small. If the existing threads
are all waiting on work that needs a new thread, then a deadlock occurs.
With this change, when a parked worker times out, it will lower max_working to
the number of active (working + parked + starting) threads minus itself (but no
less than limit_worker_min). As a result, monitor_thread will only increment
max_working as long as none of the already running workers are timing out.
Attempt to address https://github.com/mono/mono/issues/17833
---
Also allow monitor_thread to start workers if there aren't enough active, even if the max worker limit has been reached.
Work around a pathological condition where the work_item_count is non-zero, and
the max_working limit has been reached, but the number of active threads is
still below the max. In that case, unpark some workers and start some new
threads.
May address http://work.azdo.io/827206
The method InstalledInputLanguages() always returned InvariantCulture. Now, installed input languages are detected properly on Windows.
Reproducer:
`Console.WriteLine(InputLanguage.CurrentInputLanguage.Culture.TwoLetterISOLanguageName.ToUpper());`
Related issue: #13552
## Background
In Mono 5 and earlier, the active GTK or KDE theme would be sourced for system colors, allowing dark themes to be obeyed:

This allowed WinForms apps to blend in and look more like native apps.
## Problem
In Mono 6, this capability was lost (as noted in passing in #14325). WinForms apps now only look like this, regardless of the system color settings:

This looks somewhat jarring and worse than previous Mono releases, for users with a dark system theme.
## Cause
During load of the system settings (in the static constructor of `X11DesktopColors`), `Theme.SetSystemColors` passes system color data to `System.Drawing.KnownColors.Update`, which populates them into `System.Drawing.KnownColors.ArgbValues`. In Mono 5 and earlier, this flowed through to the visible UI.
It seems that as of Mono 6, this table no longer affects the visible WinForms UI (although it is still being updated!). Instead, a same-but-different table in `System.Drawing.KnownColorTable` drives the system colors now. I was not able to identify the commit in which this change was made.
## Changes
Now `Theme.SetSystemColors` accesses `System.Drawing.KnownColorTable.s_colorTable` instead, and WinForms apps once again obey GTK and KDE themes:

FixesKSP-CKAN/CKAN#2881.
These runtimes are configured with `--with-lazy-gc-thread-creation=yes` so they don't start a GC finalizer threads by themselves.
XI does this because they want to delay creating that thread for some time after startup.
We can just do it immediately, the important part is that it _does_ exist.
We need to check whether the assembly name passed to us already contains .exe/.dll and append it otherwise.
Fixes loading of assemblies via the hook, we were falling back to the usual path resolving logic (which doesn't work in netcore mode).
[arm] if mtriple is provided, do not set -march
E.g. when passing `-march=arm -mtriple=armv7s-ios`, `-march` will win and thus ignore `armv7s`.
Fixes https://github.com/mono/mono/issues/17931
* Caused by 5e318afd2e
* Related with 4cd5068230
* Almost fixed by e431093f73
Hopefully we are done with it.
### Backstory
This test is failing in the interpreter (ONLY on Debian9/amd64. Not Ubuntu/amd64. Not macOS/amd64):
https://github.com/mono/mono/blob/0fed03ed63ed4ea742c4511d8edc3bc1c6f4044f/mcs/class/Mono.Debugger.Soft/Test/dtest.cs#L2484-L2499
Where the debuggee is just some unsafe code that tries to read from unmapped memory, thus causing a segfault.
So the test expects the runtime to send a CRASH event via the managed debugger interface. This happens very late in the crash handling machinery:
https://github.com/mono/mono/blob/0fed03ed63ed4ea742c4511d8edc3bc1c6f4044f/mono/mini/mini-posix.c#L1105
However, the runtime would never reach that, because it silently crashes when calling `backtrace`:
https://github.com/mono/mono/blob/0fed03ed63ed4ea742c4511d8edc3bc1c6f4044f/mono/mini/mini-posix.c#L939
At the point where the SIGSEGV happens, the native stack trace looks like this:
```
Thread 1 "mono-sgen" received signal SIGSEGV, Segmentation fault.
interp_exec_method_full (frame=0x555555c51f18, context=0x555555c38350, clause_args=clause_args@entry=0x0, error=0x555555c53f18, error@entry=0x7fffffffd8b0) at interp/interp.c:4463
4463 sp[-1].data.i = *(gint32*)sp[-1].data.p;
(gdb) bt
%0 interp_exec_method_full (frame=0x555555c51f18, context=0x555555c38350, clause_args=clause_args@entry=0x0, error=0x555555c53f18, error@entry=0x7fffffffd8b0) at interp/interp.c:4463
%1 0x000055555569237a in interp_runtime_invoke (method=<optimized out>, obj=<optimized out>, params=<optimized out>, exc=0x0, error=0x7fffffffd8b0) at interp/interp.c:1900
%2 0x0000555555590745 in mono_jit_runtime_invoke (method=0x555555bfdc38, obj=<optimized out>, params=0x7fffffffd858, exc=0x0, error=0x7fffffffd8b0) at mini-runtime.c:3001
%3 0x0000555555778c4c in do_runtime_invoke (method=0x555555bfdc38, obj=<optimized out>, params=<optimized out>, exc=<optimized out>, error=0x7fffffffd8b0) at object.c:3052
%4 0x000055555577b7d0 in do_exec_main_checked (method=0x555555bfdc38, args=<optimized out>, error=0x7fffffffd8b0) at object.c:5184
%5 0x000055555559a2aa in mono_jit_exec_internal (argv=0x7fffffffdcb8, argc=1, assembly=0x0, domain=0x555555bf9d40) at driver.c:1320
%6 mono_jit_exec (domain=domain@entry=0x555555bf9d40, assembly=assembly@entry=0x555555c66ae0, argc=argc@entry=1, argv=argv@entry=0x7fffffffdcb8) at driver.c:1265
%7 0x000055555559b8e2 in main_thread_handler (user_data=<synthetic pointer>) at driver.c:1402
%8 mono_main (argc=<optimized out>, argv=<optimized out>) at driver.c:2622
%9 0x000055555558b757 in mono_main_with_options (argv=<optimized out>, argc=<optimized out>) at main.c:52
%10 main (argc=<optimized out>, argv=<optimized out>) at main.c:434
```
Stepping into the crash handling machinery, the picture looks a bit different:
```
Thread 1 "mono-sgen" hit Breakpoint 1, altstack_handle_and_restore (ctx=0x7fffffffd2d0, obj=0x0, flags=0) at exceptions-amd64.c:871
871 {
(gdb) bt
%0 altstack_handle_and_restore (ctx=0x7fffffffd2d0, obj=0x0, flags=0) at exceptions-amd64.c:871
%1 0x00005555556957de in interp_exec_method_full (frame=0x555555c53f08, context=0x555555c38350, clause_args=0x0, error=0x555555c53f18) at interp/interp.c:4461
%2 0x0000000000000000 in ?? ()
```
So it looks like we messed up in the transition from altstack back to the program stack.
### The fix
The problem is that `backtrace` consults the unwind information emitted at the point where SIGSEGV happens in `interp_exec_method_full ()`. However at that given program code, there is no function call that allocates space to pass arguments on the stack. Still, we massage the stack to do that in the signal handler, which does not add up with the emitted unwind information by the C compiler.
Note that without the fix, crashing in `backtrace` is the worst case. In other cases we might (1) get still a correct stack trace, or (2) we get a wrong stack trace, and `backtrace` will not crash. So this PR might improve the crash experience overall.
This also reverts commit cff400f3fae9775ac734f8a691339e59a272872c.
* Aling alloca_size to 8.
* Prevent some false pinning in the monitor-resurrection.cs test when using the non-recursive interpreter.
* [runtime] Add a mono_compiler_barrier () function.
* Add a MONO_GET_SP opcode to pass to enter/exit_gc_safe_region, ldloca might not return a native stack address with the interpreter.
* Add an interpreter/gc callback to mark the interpreter stack.
* Copy only an integer in ENDFILTER.
* Add a native_stack_addr field to InterpFrame so the EH code has something to compare against native stack addresses.
* Add a FrameStack structure to allow allocation of InterpFrame structures and stack data outside the native stack.
* Allocate InterpFrames/stack data from a frame stack instead of the native stack.
* Make some calls non-recursive.
* Remove an assert.
* Use non-recursive calls in CALLVIRT_FAST as well.
* Fix stack size allocation for vararg calls.
* Add some micro optimizations to the calling code.
* Add more micro optimizations.
* [dtest] disable Crash test on interpreter
* Add some implicit conversions to STSFLD to fix a corefx test failure.
* Disable the new test.
Fix BinaryReader on BE
The ints passed into the int array ctor needed to be endian swapped.
Interestingly, the BinaryWriter implementation currently being used
(not refsrc AFAIK) does this on write just fine.
Fixes ReadDecimal test on AIX, and adds another test to ensure that
Write(decimal) can be read back by ReadDecimal in case.
After https://github.com/mono/mono/pull/16832 was merged the run-msbuild.bat
script has an additional required parameter for specifying the GC.
However the script only passed the MONO_TARGET_GC property to msbuild
if the script had no additional parameters which doesn't make sense.
Always pass the parameter, this should fix the boehm build on Windows i386.
Mono SDB's debugger agent takes a `host:port` parameter to specify the host and
port on which to listen for debugger connection. `host` is passed, via
`mono_get_address_info`, to the `getaddrinfo(3)` standard library call which
does the job of translating the name to the IP address. However, there's no
special treatment for situations when `host` is already an IP address. In this
case `getaddrinfo` takes a lot of time to perform at least two DNS lookups (if
there's just a single DNS server configured) which will time out as the IP
address in `host` will not be resolved by any of the servers.
`getaddrinfo` takes a "hints" parameter where caller can specify some
information about the `host:port` pair to make the lookup faster/easier.
However, Mono doesn't specify the address family in the `hints` parameter, thus
forcing the slow path of DNS lookups on `getaddrinfo`.
This commit adds a new hint named `MONO_HINT_NUMERIC_HOST` (which maps to
`AI_NUMERICHOST` for `getaddrinfo`) which will allow, if set, `getaddrinfo` to
take a faster route in address discovery. Debugger agent will, in most cases,
get an IP address to instead of host name so we call `mono_get_address_info` up
to 3 times (IPv4, IPv6 and unspecified) in order to make the lookup faster.
Fix flawed BufferTest on big-endian
Test ignored byte order when considering integer comparison. This
tests different cases for each endian, and explains why the byte
order is different.
* Implement validation for signature and argument count consistency.
- throw error `Parameter count mismatch.` when arguments and signature counts are not consistent.
* Fix tests that have Parameter count mismatch.
* Add browser binding tests for `Parameter count mismatch
* Allow runtime to be built with C++ on AIX
Many AIX/PPC/BE specific codepaths didn't do casting properly,
since C++ is much stricter than C about pointer typing.
Also specify the C99 format macros early as possible, since
inttypes may get included before eglib gets a chance to set the
macros.
Also explicitly use -pthread, since not using it is the cause of
many libstdc++ crashes on AIX.
* Oops, should have been that define instead
* Suggested changes from Jay on style
* Remove unneeded cast
It's used for the zlib compression helpers used by System.IO.Compression in the old Mono BCL.
On corefx this is handled differently so we don't need it there.
To avoid automake complaining about missing files we include the .c files directly instead of in the Makefile.
Those folders won't be present in the dotnet/runtime repository.
We need to factor out AC_OUTPUT into a separate file so we can continue
to share configure.ac but not the list of files in AC_OUTPUT since
autotools doesn't support variables there.
2019-11-22 22:48:11 +01:00
736 changed files with 26088 additions and 12726 deletions
SUBDIRS=$(build_with_msvc) mk po $(libgc_dir) llvm mono $(ikvm_native_dir) support data runtime scripts man samples $(tools_dir)$(build_without_msvc)$(docs_dir) acceptance-tests
endif
# Keep in sync with SUBDIRS
DIST_SUBDIRS=$(build_with_msvc) m4 mk po $(libgc_dir) llvm mono ikvm-native support data runtime scripts man samples tools $(build_without_msvc) docs acceptance-tests netcore netcore/corerun
if!ENABLE_NETCORE
all:$(update_submodules)
@@ -116,30 +94,10 @@ mcs-do-compiler-tests:
bootstrap-world:compiler-tests
$(MAKE) install
ifINSTALL_MONOTOUCH
monotouch-do-build:config.h
@list='$(MONOTOUCH_SUBDIRS)';for subdir in $$list;do\
@@ -95,10 +95,15 @@ function InsertMaestroPrivateFeedCredentials($Sources, $Creds, $Password) {
}
if(!(Test-Path$ConfigFile-PathTypeLeaf)){
Write-Host"Couldn't find the file NuGet config file: $ConfigFile"
Write-PipelineTelemetryError-Category'Build'-Message"Eng/common/SetupNugetSources.ps1 returned a non-zero exit code. Couldn't find the NuGet config file: $ConfigFile"
ExitWithExitCode1
}
if(!$Password){
Write-PipelineTelemetryError-Category'Build'-Message'Eng/common/SetupNugetSources.ps1 returned a non-zero exit code. Please supply a valid PAT'
ExitWithExitCode1
}
# Load NuGet.config
$doc=New-ObjectSystem.Xml.XmlDocument
$filename=(Get-Item$ConfigFile).FullName
@@ -121,7 +126,16 @@ if ($creds -eq $null) {
# Insert credential nodes for Maestro's private feeds
Write-PipelineTelemetryError-Category'MaestroVars'-Message"MaestroApiVersion does not match a version string in the format yyyy-MM-DD. '$MaestroApiVersion'"
ExitWithExitCode1
}
}
catch{
Write-PipelineTaskError"Error: Variables `MaestroApiEndPoint`, `MaestroApiVersion` and `MaestroApiAccessToken` are required while using this script."
Write-PipelineTelemetryError-Category'MaestroVars'-Message'Error: Variables `MaestroApiEndPoint`, `MaestroApiVersion` and `MaestroApiAccessToken` are required while using this script.'
Write-Host"No subscriptions found for source repo '$normalizedSourceRepo' in channel '$ChannelId'"
ExitWithExitCode0
}
if(!$subscriptions){
Write-PipelineTelemetryError-Category'TriggerSubscriptions'-Message"No subscriptions found for source repo '$normalizedSourceRepo' in channel '$ChannelId'"
[string]$Repository=$env:BUILD_REPOSITORY_NAME,# Required: the name of the repository (e.g. dotnet/arcade)
[string]$BranchName=$env:BUILD_SOURCEBRANCH,# Optional: name of branch or version of gdn settings; defaults to master
[string]$SourceDirectory=$env:BUILD_SOURCESDIRECTORY,# Required: the directory where source files are located
[string]$ArtifactsDirectory=(Join-Path$env:BUILD_ARTIFACTSTAGINGDIRECTORY("artifacts")),# Required: the directory where build artifacts are located
[string]$ArtifactsDirectory=(Join-Path$env:BUILD_ARTIFACTSTAGINGDIRECTORY('artifacts')),# Required: the directory where build artifacts are located
[string]$AzureDevOpsAccessToken,# Required: access token for dnceng; should be provided via KeyVault
[string[]]$SourceToolsList,# Optional: list of SDL tools to run on source code
[string[]]$ArtifactToolsList,# Optional: list of SDL tools to run on built artifacts
@@ -22,79 +22,89 @@ Param(
[string]$TsaCodebaseAdmin,# Optional: only needed if TsaOnboard is true; the aliases which are admins of the TSA codebase (e.g. DOMAIN\alias); TSA is the automated framework used to upload test results as bugs.
[string]$TsaBugAreaPath,# Optional: only needed if TsaOnboard is true; the area path where TSA will file bugs in AzDO; TSA is the automated framework used to upload test results as bugs.
[string]$TsaIterationPath,# Optional: only needed if TsaOnboard is true; the iteration path where TSA will file bugs in AzDO; TSA is the automated framework used to upload test results as bugs.
[string]$GuardianLoggerLevel="Standard",# Optional: the logger level for the Guardian CLI; options are Trace, Verbose, Standard, Warning, and Error
[string]$GuardianLoggerLevel='Standard',# Optional: the logger level for the Guardian CLI; options are Trace, Verbose, Standard, Warning, and Error
[string[]]$CrScanAdditionalRunConfigParams,# Optional: Additional Params to custom build a CredScan run config in the format @("xyz:abc","sdf:1")
[string[]]$PoliCheckAdditionalRunConfigParams# Optional: Additional Params to custom build a Policheck run config in the format @("xyz:abc","sdf:1")
Write-PipelineTelemetryError-Force-Category'Sdl'-Message"Guardian tsa-onboard failed with exit code $LASTEXITCODE."
ExitWithExitCode$LASTEXITCODE
}
}else{
Write-PipelineTelemetryError-Force-Category'Sdl'-Message'Could not onboard to TSA -- not all required values ($TsaCodebaseName, $TsaNotificationEmail, $TsaCodebaseAdmin, $TsaBugAreaPath) were specified.'
Write-PipelineTelemetryError-Force-Category'Sdl'-Message"Guardian tsa-publish failed with exit code $LASTEXITCODE."
ExitWithExitCode$LASTEXITCODE
}
}else{
Write-PipelineTelemetryError-Force-Category'Sdl'-Message'Could not publish to TSA -- not all required values ($TsaBranchName, $BuildNumber) were specified.'
Write-Host"Guardian tsa-onboard failed with exit code $LASTEXITCODE."
exit$LASTEXITCODE
}
}else{
Write-Host"Could not onboard to TSA -- not all required values ($$TsaCodebaseName, $$TsaNotificationEmail, $$TsaCodebaseAdmin, $$TsaBugAreaPath) were specified."
@@ -215,8 +236,11 @@ function InstallDotNet([string] $dotnetRoot,
&$installScript@installParameters
}
catch{
Write-PipelineTelemetryError-Category"InitializeToolset"-Message"Failed to install dotnet runtime '$runtime' from custom location '$runtimeSourceFeed'."
Write-PipelineTelemetryError-Category'InitializeToolset'-Message"Failed to install dotnet runtime '$runtime' from custom location '$runtimeSourceFeed'."
ExitWithExitCode1
}
}else{
ExitWithExitCode1
}
}
}
@@ -238,16 +262,16 @@ function InitializeVisualStudioMSBuild([bool]$install, [object]$vsRequirements =
Write-PipelineTelemetryError-Category"InitializeToolset"-Message"-msbuildEngine must be specified, or /global.json must specify 'tools.dotnet' or 'tools.vs'."
Write-PipelineTelemetryError-Category'InitializeToolset'-Message"-msbuildEngine must be specified, or /global.json must specify 'tools.dotnet' or 'tools.vs'."
ExitWithExitCode1
}
@@ -431,9 +458,9 @@ function GetNuGetPackageCachePath() {
# Use local cache on CI to ensure deterministic build,
# use global cache in dev builds to avoid cost of downloading packages.
Loaded 100 of 736 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.