* [wasm][debugger][tests] Move the test files to `tests/debugger`
- Also, rename `class Math` to `class SampleMath` in `sample.cs`,
to allow building sample.dll, with all the tests added.
* [wasm][debugger][tests] Add back missing dependency
* [wasm][debugger][tests] move *datetime-test.cs to `tests/debugger`
* [wasm][debugger][tests] Move CFO test to debugger-cfo-test.cs
* [wasm][debugger] Only send resolved events on load
* Add the request to the context after potentially loading the store
* improve the resolution logic
Co-authored-by: Larry Ewing <[email protected]>
* [wasm][debugger] Only choose the best match when mutiple locations are found
* OrderBy column just to be certain
* Add tests for the JS breakpoint behavior that we are duplicating
* remove accidentally disabled code
Wasm has control flow limitations which don't go well with gotos. Move label outside of main loop because it translates to very poor wasm code. Other gotos don't seem to negatively impact instruction dispatch code, so leave them alone, for now ..
Co-authored-by: BrzVlad <[email protected]>
* [wasm][debugger][tests] Move helper methods to base class
* [wasm][debugger][tests] Extract EvaluateOnCallFrame tests to new file
* [wasm][debugger][tests] Extract Array tests to a new file
* [wasm][debugger][tests] Extract CallFunctionOn tests to a new file
* [wasm][debugger][tests] Extract Delegate tests to a new file
* [wasm][debugger] Don't inherit from another test class
.. as that ends up running all the tests of the base class too.
* [wasm][debugger][tests] Improve retries in TestHarnessStartup
Sometimes `/json/list` seems to return an empty array (`[ ]`). Treat
that also as a case for retry.
* [wasm][debugger][tests] Bump timeout from 2s to 5s
* [wasm][debugger][tests] Launch chrome in incognito mode
* debugging
* [wasm][debugger] TestHarnessStartup - don't share `ProcessStartInfo`
.. instances. Instead, create one for every use.
We seem to run into cases where the `get_Environment` is modifying it's
`_environmentVariables` field, concurrently from multiple threads,
causing exceptions like:
```
System.IndexOutOfRangeException: Index was outside the bounds of the array.
at System.Diagnostics.Process.CreateEnvp(ProcessStartInfo psi)
at System.Diagnostics.Process.StartCore(ProcessStartInfo startInfo)
at System.Diagnostics.Process.Start()
at System.Diagnostics.Process.Start(ProcessStartInfo startInfo)
at WebAssembly.Net.Debugging.TestHarnessStartup.LaunchAndServe(ProcessStartInfo psi, HttpContext context, Func`2 extract_conn_url) in /Users/radical/dev/w1/sdks/wasm/ProxyDriver/TestHarnessStartup.cs:line 82
at WebAssembly.Net.Debugging.TestHarnessStartup.<>c__DisplayClass10_0.<<Configure>b__1>d.MoveNext() in /Users/radical/dev/w1/sdks/wasm/ProxyDriver/TestHarnessStartup.cs:line 167
```
* [wasm][debugger] Fix regression in debug.html
Fixes https://github.com/mono/mono/issues/19653 .
Co-authored-by: Ankit Jain <[email protected]>
* [wasm] Reenable the managed collation code, link it out by default, add a packager option to enable it.
* Disable some xunit tests which fail because the test runner can't handle the [SkipOnTargetFramework(TargetFrameworkMonikers.Mono)] attribute.
* [csproj] Update project files
Co-authored-by: Zoltan Varga <[email protected]>
* Add throwing PNSE to where currently disabled tests throw something different
* Add try-catch + PNSE to public SslStream ctor in case of WASM
Co-authored-by: Maxim Lipnin <[email protected]>
* [wasm][debugger] `mono_wasm_call_function_on` - remove unncessary
.. parameter, since it is already present in the `args` object.
* [wasm] MonoProxy - convert cfo calls to MonoCommands
* [wasm][debugger] Fix enumerating `this` properties for a valuetype
* [wasm][debugger] `evaluateOnCallFrame` - fix `this` for valuetypes
* [wasm][debugger] Remove MonoCommands no longer used
* [wasm][debugger] Fix showing the name for generic methods
- We were using `method.Name` from Cecil, but that we want to the name
with the type arguments for the generic instance.
Co-authored-by: Ankit Jain <[email protected]>
* [wasm][debugger] send failed evaluations to the browser
Make sure that we allways either send a single result or return
false from Accept Command to ensure that we don't leave
messages spinning.
Co-authored-by: Larry Ewing <[email protected]>
* [wasm][debugger] Move `getProperties` implementation to `library_mono.js`,
.. from `MonoProxy.cs`. MonoProxy essentially just forwards the
request to `library_mono.js` now.
* [wasm][debugger] Add `length` info array details
- update tests to track the change
* [wasm][debugger][tests] Simplify some of the helper methods
* [wasm][debuggger] Implement `Runtime.callFunctionOn`
- This was prompted by vscode/vs requiring this for array expansion.
- It runs a given js function string, on a given object id.
- We handle the case for dotnet object ids.
Implementation:
- We build a proxy object that reflects the details of the real dotnet object/array
- And run the js function on that proxy object
- Then if `returnByValue` was requested, the result is returned as-is
- Else we cache that object, with a new special object id (`dotnet:cfo_res:..`),
and return that id in the response.
- Subsequently, we would get `Runtime.getProperties` request on this new object id
- And a `Runtime.releaseObject` request, to free that function result.
- All this is handled currently
Tests:
- A few tests were added which invoke `callFunctionOn`, on JS objects, and checks the result
- And the same checks are performed on equivalent dotnet objects, with the same js function
- This should help stay in sync with what we think `callFunctionOn` should work as
- These tests have an additional parameter - `roundtrip`, which calls a simple function
`function () { return this; }`
.. on a dotnet object, and gets the result object id. If `roundtrip == true`, then it
runs that same function on the result object, and gets a new result object id. And the
tests run their checks on that.
- this helps to check that outside of the proxy, the result object behaves same as any
other dotnet object.
- Also, most of the tests were modified to support an additional mode (`use_cfo`).
- With this, whenever a test wants to run `Runtime.getProperties on an object, we pass that
object through the earlier "identity" function, and then run `getProperties` on that
resultant object.
- This helps to take advantage most of the existing tests, and use them for `callFunctionOn`
testing too, by ensuring that the results of CFO returns results same as any other object.
Fixes https://github.com/mono/mono/issues/19229, https://github.com/mono/mono/issues/19531
* Apply suggestions from code review
Applying suggestions to start CI
* Update sdks/wasm/src/library_mono.js
Co-authored-by: Ankit Jain <[email protected]>
Co-authored-by: Larry Ewing <[email protected]>
* [wasm][debugger] Add an option to clear navigator.webdriver on attach
* Pass the flag when it is useful
Co-authored-by: Larry Ewing <[email protected]>
With embedded pdbs we have to try to load symbols even when the
pdb is missing then handle ArgumentException if there is no embedded
pdb. This restores the intended error path and added an explanation
while still logging unexpected errors
Co-authored-by: Larry Ewing <[email protected]>
* [wasm][debugger] Show signature for delegate, or target, if available (#19505)
* [wasm][debugger] Show signature for delegate, or target, if available
- As object properties, we return a `Target` which has the signature of
the delegate target.
Fixes https://github.com/mono/mono/issues/19382
* [wasm][debugger] Some tidying up
* [wasm][debugger] Remove unused `sig_desc`
* [wasm][debugger] Simplify code, avoid extra allocations
.. as suggested by @lewing
(cherry picked from commit 4eca12e794)
* [wasm][debugger] Fix tests broken because unused vars are not null
.. anymore, which is because we disabled optimizations in the
interpreter when debugging.
* [wasm][debugger][tests] Add tests to also check delegates in previous
.. frames.
* [wasm][debugger] Disable a test that tried to look at previous async
.. frames. This just happened to work. Currently, the trace has details
of the async machinery, instead of one reflecting what it might have
looked like for a non-async case. So, we can't reliably find the
previous method to inspect it's locals.
* [wasm][debugger] Fix test
Co-authored-by: Ankit Jain <[email protected]>
* [wasm][debugger] Rework source loading
Add logic to support embedded sources and
add all the documents from multi-doc methods
Add logic to check source hashes against
pdb hash.
* [wasm][debugger] Fix breakpoints on delegates
Only add methods to a source once by RID
When column is != 0 specified the fronted only wants results
that match that column exactly.
* Allow checking pdb hash and remove source cache
* Fixup typesByName merge
* Disable the Loaded: messages, they are not very useful.
* Add a Dotnet-test.setBreakpointByMethod protocol extensions to the proxy to set breakpoints in specific methods during testing.
* Add a new sample debugger test using the setBreakpointByMethod API.
* Remove some unrelated changes.
* Restore logging.
* Disable a log message which is printed when a pdb file is missing.
Co-authored-by: Zoltan Varga <[email protected]>
* [wasm][debugger] Show signature for delegate, or target, if available
- As object properties, we return a `Target` which has the signature of
the delegate target.
Fixes https://github.com/mono/mono/issues/19382
* [wasm][debugger] Some tidying up
* [wasm][debugger] Remove unused `sig_desc`
* [wasm][debugger] Simplify code, avoid extra allocations
.. as suggested by @lewing
(cherry picked from commit 4eca12e794)
Co-authored-by: Ankit Jain <[email protected]>
* [wasm][debugger] Fix up `value.description` for local vars too
- Local vars, when being enumerated in `mono_wasm_get_variables` don't
have an associated `name`, and so `_fixup_name_value_objects`
*incorrectly* ends up not fixing up the `value.description` field for
them.
* [wasm][debugger] For some types, use `ToString()` for their ..
.. `description`.
- `System.DateTime`
- `System.DateTimeOffset`
- `System.Decimal`
- `System.TimeSpan`
- `System.Guid`
* [wasm][debugger] Invoke all property getters, for some types
- `System.DateTime`
- `System.DateTimeOffset`
- `System.TimeSpan`
* [wasm][debugger] Show char symbol along with the code
Fixes https://github.com/mono/mono/issues/19381
* [wasm][debugger] Fix DateTime tests, don't use hardcoded strings for
.. description. Instead, use a `DateTime` object in the test to create
the expected string for the test. This should ensure that the expected
and actual were created in the same environment.
* [wasm][debugger] Special case `System.Guid` to use
.. `mono_guid_to_string`, instead of calling `ToString()` on it.
* [wasm][debugger] Don't box valuetypes for calling `ToString()`
Co-authored by @vargaz .
* [wasm][debugger] `System.Guid` is special-cased, so remove it from the
.. allowed list.
* [wasm][debugger] simple cleanup
Co-authored-by: Ankit Jain <[email protected]>
* [wasm][bcl] Handle correctly backslash in file name
- Modify IO file to assign backslash to alternate directory separator by default
- Add tests for issue https://github.com/mono/mono/issues/18933
* [wasm][tests] Skip two tests for wasm
- After internal discussions decided to skip these two tests on wasm
1. GetDirectories_Backslash
1. GetFiles_Backslash
* [wasm][tests] PathIsRooted tests failing
- skip subtest #9 if WASM
- To fix issue https://github.com/mono/mono/issues/18933 we set the AltDirectorySeparatorChar as well. This causes the `Assert.IsTrue (!Path.IsPathRooted ("\\"), "IsPathRooted #09");` to fail. Path.IsPathFullyQualified Method handles paths that use both the DirectorySeparatorChar and the AltDirectorySeparatorChar characters.
* [wasm][tests] PathIsRooted tests failing
- skip if WASM
Co-authored-by: Kenneth Pouncey <[email protected]>
* [wasm][debugging] pass enable_debugging as debug engine log level
enable_debugging was already an int, with this change log_level
will remain at 1 by default but passing -1 will disable the log
spew
* Change the default debug level of 'Failed to lookup sequence point'
Co-authored-by: Larry Ewing <[email protected]>
* - Adding tests to evaluate expression
- Adding a cache to local vars and object properties
- Fixing evaluate expressions like "this.a"
- Fixing evaluate expressions like "d + d"
Co-authored-by: Thays Grazia <[email protected]>
I changed the frame_id, so we will follow the frame_id from callstack even if we don't add all of them into the CallStack list in MonoProxy.
I also added a test.
Fixes#19379
* [wasm][bcl] TimeZoneInfo implementation for WebAssembly to read from WASM VFS `/zoneinfo`.
- Remove `TimeZoneInfo.WebAssembly.cs` file
- Remove source dependencies on `TimeZoneInfo.WebAssembly.cs`.
- Modify TimeZoneInfo for specific WASM functionality
- Default root directory is `zoneinfo`
- Add icall `mono_timezone_get_local_name` for WASM in CreateLocal
- Add icall implementation
- ves_icall_System_TimeZoneInfo_mono_timezone_get_local_name
* [wasm][build] Add `-s FORCE_FILESYSTEM=1` to mono wasm runtime build
- Required so that it includes support for loading pre preload packages
Message when generating the zoneinfo data.
> Remember to build the main file with -s FORCE_FILESYSTEM=1 so that it includes support for loading this file package
* [wasm] zoneinfo data and support files.
- Three files for zoneinfo VFS support.
- `mono-webassembly-zoneinfo-fs-smd.js.metadata` - This is the separate metadata output by emscripten file-packager. Used to parse the zoneinfo data in non browser environments. See `runtime-tests.js`
- `mono-webassembly-zoneinfo-fs.js` - Output by emscripten file-packager that will be referenced by browser environments to load the zoneinfo data into the VFS at `/zoneinfo`
- `zoneinfo.data` - The binary file output by emscripten file-packager. The file contains the actual zoneinfo data loaded into the VFS and parsed by `TimeZoneInfo`.
* [wasm][driver] Add backing support for icall `mono_timezone_get_local_name`
* Add TimeZone info test.
* [wasm][packger] Add `-s FORCE_FILESYSTEM=1`
- Required so that it includes support for loading preload packages
Message when generating the zoneinfo data.
> Remember to build the main file with -s FORCE_FILESYSTEM=1 so that it includes support for loading this file package
* Fix AOT tzd test
* Remove commented code lines for `TimeZoneInfo.WebAssembly.cs` module
* Regenerated zone info without --no-heap-copy as it causes problems. This will create a warning in browser for now.
* Add zoneinfo support files to package
* Fix TimeZoneInfo tests to use the `--enable-fs` packager parameter
* Add back icall implementation after rebase
- ves_icall_System_TimeZoneInfo_mono_timezone_get_local_name
* Add back backing support for icall `mono_timezone_get_local_name` after rebase
* Fix build error
* Add back zoneinfo tests to Makefile after rebase
* Fix packager zoneinfo sample builds.
* Address review comment about volatile not needed
* Address review comment about volatile not needed
* Address review comment about volatile not needed
* Address review comment volatile not needed
* [wasm][debugger][tests] Refactor test support methods
.. which will help in the upcoming changes.
* [wasm][debugger][tests] Add tests for arrays
- These don't include the broken cases which are fixed in the next
commits
* [wasm][debugger][tests] Fix enumerating locals in async method on a
.. struct.
* [wasm][debugger] Support ValueTypes in arrays
- ValueTypes in array elements are not expanded by default. Instead,
they get an object id like `dotnet:array:{arrayObjectId}:{index}`
- And these get expanded on request
* [wasm][debugger] Fix calls to `mono_wasm_add_null_var` from js
- when being called from `library_mono.js`, with a native string like -
`MONO.mono_wasm_add_null_var ("string");`
.. which when passed to `Module.UTF8ToString (className)`, returns
`null`. So, if the result of that call is null, then use the `className`
argument as-is.
* [wasm][debugger][tests] Add test for local structs in an async method
* [wasm][debugger][tests] Add `TEST_ARGS` and `TEST_FILTER` arguments to
.. control `dotnet test` arguments.
Example use:
`make run-debugger-tests TEST_ARGS="--filter FullyQualifiedName~ArraysTests"`
or
`make run-debugger-tests TEST_FILTER="ArraysTests"`
* [wasm][debugger][tests] Make `label` the last argument, consistently.
* [wasm][debugger] Address review comments
- Return a `Result` response, instead of throwing an exception
* dummy commit to kick the pr
* [debugger][wasm] Implement evaluate in wasm debugger.
-> evaluate expressions with constant values and variable values are working
-> evaluate expressions with methods not working yet
-> evaluate expressions with assignments not working yet
* removing extra ;
* Update sdks/wasm/Mono.WebAssembly.DebuggerProxy/EvaluateExpression.cs
Co-Authored-By: Larry Ewing <[email protected]>
* Update sdks/wasm/Mono.WebAssembly.DebuggerProxy/EvaluateExpression.cs
Co-Authored-By: Larry Ewing <[email protected]>
* Update sdks/wasm/Mono.WebAssembly.DebuggerProxy/EvaluateExpression.cs
Co-Authored-By: Larry Ewing <[email protected]>
* Fix what was suggested by @radical.
* Changing what @radical suggested
* Changing what @radical suggested
Co-authored-by: Larry Ewing <[email protected]>
* When we run an invoke in a thread and after this we do a set_value and then a get_value, when we call set_value we consider restore_state, but when we call get_value we are not considering the restore_state.
Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1077790
…asses
Follow CoreCLR's example and add the RTSpecialName type attribute to any class field with the 'value__' name when , used as the value store for enumeration class instances.
Second part of the "RTSpecialName fix" that started with https://github.com/dotnet/runtime/pull/33389 - before, our behavior was to add the RTSpecialName immediately, as soon as the EnumBuilder was constructed.
Contributes to https://github.com/dotnet/runtime/issues/2389
Co-authored-by: alexischr <[email protected]>
Since 3 days ago, Mono WebAssembly no longer works on Firefox. The error is `ReferenceError: SharedArrayBuffer is not defined`.
This PR adds a trivial fix.
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]>
* [loader] Add append option to loader hook installation functions
Fixes https://github.com/dotnet/runtime/issues/34273
While this specific issue only affects the preload hook, I've added the append option to all the installation functions since this seems like a generally useful capability, both for internal use and embedders.
@BrzVlad tested locally and confirmed this patch solves the problem.
* Update callers in pedump and monodis
Co-authored-by: CoffeeFlux <[email protected]>
Co-authored-by: Ryan Lucia <[email protected]>
* [wasm][debugger] Move some of the variable name/value pairs fix up to
.. library_mono.js from MonoProxy.
* [wasm][debugger] Handle invalid scope id
- this would throw NRE, and the request would fail, and so the test
passed.
* [wasm][debugger][tests] Check functionName at breakpoints
.. and fix up tests.
* [wasm][debugger][tests] Remove unnecessary `ctx` arg
* [wasm][debugger] Add support for visualizing valuetypes
- Valuetypes are expanded into json, and cached. That gets used to
answer any `getProperties` request for them.
- When a valuetype is a local var, it's whole value expansion is
returned in `members` json field. This gets cached by MonoProxy, and
used to answer any `getProperties` requests for it's members.
- When a valuetype is part of an object, it is *not* expanded. Instead,
it gets an objectId of the form `dotnet:valuetype:containingObjectId:fieldOffset`.
- Later, when the debuggers asks for that special id, we expand *all*
the valuetypes in that containing object, and cache it.
- For properties, the property "number" as they are enumerated, is
used instead of the fieldOffset.
- this cache gets cleared whenever we step/resume the debugger.
* [wasm][debugger] Add support for visualizing enums
TODO: Flags
* [wasm][debugger] Don't invoke property getters when enumerating object
.. members.
* [wasm][debugger] Override `ToString` for `Result` class
sets.
Making associated change to type_in_image to also check the constrained type for a match. Re-adding asserts now they they no longer trigger.
fixup, accidentally used old function
adjusting coding convention to K&R
Starting with https://github.com/mono/mono/pull/16907 , the runtime ends in GC-Safe state (mode) after mono_jit_init_version() is called. mono_gc_init_finalizer_thread() expects the GC to not already be in safe mode.
Turns out `llvm::Triple(llvm::sys::getDefaultTargetTriple()).getArchName()` doesn't work as expected on all targets so the only option is to set arch via defines.
NOTE: it accepts "x86-64", not "x86_64
Co-authored-by: EgorBo <[email protected]>
`EB.selectTarget ();` used to return `NULL` on arm64 (and hit an assert later)
Turns out it needs MArch on arm (e.g. `"aarch64"`) set. No idea why it doesn't use host arch by default on arm (but works on x86).
Co-authored-by: EgorBo <[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.
Fixes: https://github.com/dotnet/runtime/issues/34304
@tannergooding @davidwrighton
Now it fully matches clang/LLVM behavior, e.g. even `-mattr=+avx2` (or `-mavx2` in clang) doesn't enable `pcmul` and `aes`. However, `-mattr=+sse4.2` (`-msse4.2`) enables `popcnt` (see https://godbolt.org/z/RWAp_D). The intel manual says

So is there a CPU with AVX set but without `popcnt`? The instruction is pretty useful (it is used in BCL) users might forget to define it when they use `mattr=avx` (or `mattr=avx2`).
However in C++ world programmers use named groups e.g. `mcpu=haswell` rather than listing these sets via attributes.
Co-authored-by: EgorBo <[email protected]>
Improve LLVM 9 compatibility.
Several intrinsics were removed in LLVM 7 and above; replace them with
IR sequences that generate the desired instructions.
Fix some type mismatch problems with the generated IR (in
Sse2.StoreAlignedNonTemporal, Vector128.CreateScalarUnsafe, and
Sse2.MaskMove); these were caught by running the coreclr hardware
intrinsic JIT tests.
Support the two-argument forms of Sse.SqrtScalar, Sse.ReciprocalScalar,
and Sse.ReciprocalSqrtScalar.
llvm::linkCoreCLRGC(), in llvm/CodeGen/GCs.h, was removed and replaced with
llvm::linkAllBuiltinGCs(), in llvm/CodeGen/BuiltinGCs.h.
In mono_llvm_dump_value and mono_llvm_dump_module, flush the c library's
stdout stream before using (and flushing) LLVM's own buffered output
functions.
Co-authored-by: imhameed <[email protected]>
* [Wasm] Fix string_decoder when running with threading enabled
Avoids the following error message:
```
Failed to execute 'decode' on 'TextDecoder': The provided ArrayBufferView value must not be shared.
```
* [Wasm] Cache text decoder
* [wasm] Throw an exception from Monitor.Wait () in non-threaded mode.
* [wasm] Throw an exception when waiting for unsignalled events in non-threaded mode.
* [wasm] Bump emscripten to 1.39.11.
* [wasm] Build the debug runtime using -g, -g4 disables dwarf.
* Add runtime debugging docs.
* Avoid copying the dotnet.wasm.map file its not generated anymore with dwarf.
* fix clean target
* Upgrade project to netstandard2.1 and change to not append framework when publish
* Move projects to netstandard2.1
* Remove code referencing framework paths
This should enable creation of a collectible ALC from managed, though it will not actually unload properly when Unload is called. This should be enough to unblock Xamarin porting work.
If you think the `mono_alc_cleanup` work is just noise I can remove that, but I thought it helpful to check in to make future diffs clearer as I split it up with the LoaderAllocator work.
Co-authored-by: CoffeeFlux <[email protected]>
When hitting stackoverflow on Windows, the amount of stack available to exception handler is too small. Windows doesn't support alt stack as other platforms, but there is a way to guarantee a certain amount of available stack during stack overflow exceptions using
SetThreadStackGuarantee.
Fix add support on Windows platforms including SetThreadStackGuarantee API to reserve space needed to handle stack overflow exceptions. On Windows debug build the size needs to be larger since we might end up calling JIT that could have quite deep callstack that, on unoptimized
builds, will need more stack.
Co-authored-by: lateralusX <[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]>
On windows, remote end point client will not return file name, but socket address size still isn't `0x02`.
So check empty file name after bytes readed.
* [wasm][sdk] Add functionality to override the bindings framework location
- Facilitate testing of intree build during the browser tests.
* white space
* Implementing step through multithreaded code.
* Fixing concurrency in the case that more than one thread will run the same code, then when the jit is finished, the thread which jitted the code calls jit_done and the others that were waiting don't call, in this case, the other threads can run before the thread which is calling the jit_done set the breakpoint, so the other threads will not stop in the breakpoint.
As I understood we don't need to check if the try_suspend_runtime is returning false or true when we hit a breakpoint from context, so removed the call.
Fixes#14456
Co-authored-by: Aleksey Kliger (λgeek) <[email protected]>
Co-authored-by: monojenkins <[email protected]>
* Reenable a bunch of disabled iOS Mono SDKs test suites
System, System.Net.Http, System.Web.Services, Mono.CSharp and Mono.Data.Sqlite test suites are running now.
Also tweaks the test UI so you can query it via Xcode's UITest in an automated way.
* Switch to APIs from public headers added in 1425b4d4d0
See https://github.com/dotnet/runtime/pull/33633 and https://github.com/xamarin/xamarin-macios/blob/master/runtime/exports.t4
* `mono_install_load_aot_data_hook` was already a `MONO_API`, but it was not in a public header.
It is added to `mono/jit/mono-private-unstable.h`
* `mono_gc_init_finalizer_thread` was [used by Xamarin.iOS](https://github.com/xamarin/xamarin-macios/blob/63ab48e679716264b33af00f86c24426da1d9f97/runtime/mono-runtime.h.t4#L278) for a long time without being in any public header. It's one of the reasons we have to compile Mono for XI with `--disable-visibility-hidden`. Make the function a proper `MONO_API` unconditionally - but make it do nothing if the runtime is compiled without `--with-lazy-thread-creation` (the default). It is now a public Mono API function.
* `mono_trace_init` was a `MONO_API` function in a non-public header that was already used by embedders that need to set up logger hooks. It is now not necessary to call this before calling the logger functions to set up logger hooks such as `mono_trace_set_log_handler`
Co-authored-by: lambdageek <[email protected]>
* [interp] Move INDIRECT flag to a separat counter variable
We will optimize away some ldlocas, so a local can stop being indirect at a future cprop iteration.
* [interp] Replace ldloca + ldfld/stfld pairs with ldloc/stloc
If loaded/stored field is the only field of the valuetype. This is meant to mainly optimize IntPtr accesses.
* [interp] Add counter for removed LDLOCA
CoreCLR static link vcruntime140.dll, but dynamic link rest of C-runtime using ucrt.lib in release build. Commit align Mono runtime to follow same pattern, removing dependency on vcruntime140.dll.
Co-authored-by: lateralusX <[email protected]>
Current implementation always returned true for Windows/Linux/Android. There are however use of this API in Task library to make sure recursive tasks won't hit stackoverflow. There are several tests in System.Threading.Tasks that currently hit this, at least on Windows, causing test failures.
Fix use stack limits already setup in register_thread and used by GC when doing conservative stack scan. If the limits have not been setup or is not supported on platform, we will use old defaults, always assume there is enough stack space available. Heuristics around size of minimum execution
stack needed are picked from corresponding CoreCLR implementation.
With this fix all tests run in System.Threading.Tasks.Tests pass on Windows using Mono runtime:
```
=== TEST EXECUTION SUMMARY ===
System.Threading.Tasks.Tests Total: 682, Errors: 0, Failed: 0, Skipped: 3, Time: 11,419s
----- end 2020-03-20 13:43:35,72 ----- exit code 0 ----------------------------------------------------------
```
Before fix the following tests hit stackoverflow:
LongContinuationChain_ContinueWith_DoesNotStackOverflow
LongContinuationChain_Unwrap_DoesNotStackOverflow
LongContinuationChain_Await_DoesNotStackOverflow
RunStackGuardTests
Co-authored-by: lateralusX <[email protected]>
unbox tramp method addresses are emitted as a table of calls and read
at runtime by get_call_table_entry. This is problematic on platforms
that doesn't allow data to be read from instruction stream.
Fix follow same pattern as we method address table emitted as function
pointers into table in data segment when using MONO_ARCH_CODE_EXEC_ONLY.
We have functions that are de-facto part of the Mono embedding API that are
used by Xamarin.iOS or Xamarin.Android that are not in a state where we want to
commit to supporting them forever in their current form.
Nonetheless, we would like to make sure that the symbols for these functions
are visible even if we otherwise compile the runtime with
`-fvisisibility=hidden`, and we would like to discourage declaring the
functions in the embedder's own headers.
The functions that go into the
`mono/{utils,metadata,jit}/mono-private-unstable.h` headers will all be marked
with `MONO_API MONO_RT_EXTERNAL_ONLY` but we will not guarantee that the
functions will be there from one release to the next or that they will not
change their signatures or their behaviors.
Co-authored-by: lambdageek <[email protected]>
* [jit] Perform inlining earlier during call processing to avoid loading vtable/rgctx args which are not needed.
* Avoid inlining calls marked with .tail.
* [llvm] Use the _typed version of get_aotconst () everywhere. Lowercase aotconst variable names.
* [llvm] Unify the emission of GOT access. NFC.
* [llvm] Unify the mini_llvm_init_method icalls, use only 1 icall.
MINT_TYPE_P is equivalent to the integer versions. By removing it we reduce the number of interpreter types and instructions, making it also easier to apply optimizations on instructions targeting these types.
Previously it would print a warning, only, because otherwise we would get a
second assert in the same place while the crash machinery would run from the
current thread from the abort in `mono_fatal_with_history`
The solution is to turn off the "no safepoints" bit since we know we're
definitely going to assert here.
Also record the current state in the checked mode state transition history to
make it a bit easier to diagnose where the problem surfaced.
Also fixed up a pair of other debugging/tracing messages so the message strings
accurately reflect the state.
- Changed the behavior on debugger-agent, if we can't parse the new behavior is to return invalid_argument and not assert and stop debugging
- Changed the mono_domain_set_fast before return from assembly_commands.
- Add error message when return INVALID_ARGUMENT
Fixes#19146
Resolves#18528 in for both detection and compiling. This should backport cleanly to next release.
Tested on 12.1-RELEASE with libinotify; configure detects features correctly, compiles successfully, resolves some observed issues during run.
```
#define HAVE_SYS_INOTIFY_H 1
#define HAVE_LIBINOTIFY 1
#define HAVE_INOTIFY_INIT 1
#define HAVE_INOTIFY_ADD_WATCH 1
#define HAVE_INOTIFY_RM_WATCH 1
#define HAVE_INOTIFY 1
```
All these functions are MONO_RT_EXTERNAL_ONLY and they all allocate managed
objects.
Fixes a coop state machine assertion if an embedder calls the function and it needs to take the GC
lock to do a collection.
Co-authored-by: lambdageek <[email protected]>
Running System.Runtime.Serialization.Xml test suite triggers calls to mono_code_manager_reserve with 0 size code block. On Windows, allocating code regions from code manager will also add callback for code region into unwinder function table, but since region could be 0 length, it will be causing a crash in RtlInstallFunctionTableCallback OS call.
Fix hardens code to not try to register callbacks for code regions of size 0, since that is considered a critical error by Windows OS API.
Co-authored-by: lateralusX <[email protected]>
* [interp] Extract nint/nfloat intrisifying code into separate method
* [interp] Optimize out intptr ctor
We avoid the newobj_vt opcode and the ctor's contents by emitting a conversion opcode directly.
Fix makes sure runtime checks also report that SIMD has been disabled. Returning FALSE from is_simd_supported will turn of MONO_OPT_SIMD and disable all SSE/AVX cpu features will prevent code checking cpu capabilities to emit SIMD instructions.
Co-authored-by: lateralusX <[email protected]>
browser tests were failing with node command not being found if the other tests were not run before. This makes sure that the NPM command can be found by installing it if not there.
This also separates out the npm version that is being installed.
Current implementation didn't convert the JIT flags into options on cfg
meaning that code currently checked JIT_FLAG_CODE_EXEC_ONLY never
executed. Fix handles the new JIT flag in same way as other JIT flags,
converted into bit field on cfg.
* [jit] Transition the SIMD code to use the MONO_CPU_... set of flags instead of the SIMD_VERSION_... flags.
* Enable SIMD version checking when targeting llvm.
* AOT test assemblies using -mcpu=native.
* Remove unused mono_arch_cpu_enumerate_simd_versions (). Move the SIMD_VERSION_ constants to simd-intrinsics.c.
* Use -mcpu=native for aot testing.
* [metadata] Change mono_trace levels from info to debug
* [mini] Change mono_trace level from info to debug
* [sgen] Change mono_trace levels from info to debug
* Amended metadata changes
* Amended mini changes
* Amend assembly.c no special case
* Amend sgen-mono.c elevate to warning level
Co-authored-by: Mitchell Hwang <[email protected]>
Implement all `Ssse3` and `Sse42` intrinsics for LLVM back-end.
`Sse41` is left over (that's why `Sse42.IsSupported` still returns false always outside of corelib)
Godbolt: https://godbolt.org/z/7cd7q5
Co-authored-by: EgorBo <[email protected]>
https://github.com/dotnet/runtime/pull/33465 implemented 99% of them but a few were missing. This PR implements the missing pieces and unlocks `Sse2.IsSupported`.
@vargaz I hope I didn't step on your toe (feel free to close if you already have it locally).
Co-authored-by: EgorBo <[email protected]>
* [interp] Add support for the coverage profiler.
* [runtime] Add 'write-at-method' and 'send-to-method' options to the coverage profiler, they work similarly to options in the AOT profiler.
* Fix c++-isms.
If the runtime is shutting down, instead of creating a new thread, or throwing
an exception on the current thread, just shut down the current thread.
This takes advantage of `mono_threads_set_shutting_down`'s behavior that if you
call it after shutdown is already started, it will suspend, detach and exit
from the current thread.
Fixes https://github.com/dotnet/runtime/issues/31842
Co-authored-by: lambdageek <[email protected]>
That call ends up in mono_debugger_agent_send_crash which does all kinds of questionable stuff like trying to take the loader lock. Eventually it ends up calling socket_transport_send which tries to do a transition to GC Safe mode.
I inserted a MONO_ENTER_GC_UNSAFE in mono_debugger_agent_send_crash function and this fixes the assert.
Fixes#18794
store a converter object for each type string passed in
use that object to simplify the marshalling step. do one allocation
for arguments and exceptions.
* [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.
SDK builds done under WSL was done like Cygwin in order to be a
Cygwin replacement going forward. This has caused issues when building
sdk's under WSL when Linux is the assumed build host.
Adding an additional define where WSL build host can be overridden to
Windows, but default will now be Linux. This can in future be used
from configure scripts, setting it in sdks/Make.config when needed,
but will be an opt in feature to override Linux as default build host
for WSL.
First set of changes needed in order to start sharing managed EventSource/EventPipe code between CoreCLR and Mono runtime. Shareable code has been moved into S.P.C library project and split into runtime specific source files when needed, kept within each runtime specific S.P.C project files.
Mono runtime has been extended with a set of icalls needed by EventPipeInternal, just to make sure EventPipe can be initialized, current Mono runtime implementation returns dummy values.
Current change also enables ETW provider support on Mono Windows runtime.
NOTE, this is just initial changes needed in order to share managed EventSource/EventPipe code between runtimes. Future changes will incrementally add EventPipe native code into Mono runtime.
Co-authored-by: lateralusX <[email protected]>
* [interp] Add missing intrinsics for double Math operations
* [interp] Add math intrinsics for float operations
* [interp] Add more math intrinsics
With different type of signature
* [interp] Remove intrinsic for Round for now
Which has different semantics from the libc's round
This adds an option the standalone-benchmark runner to extract the package zips created with the package target and available from jenkins for commits to master.
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.
Whenever there must be a loop that goes indefinitely, there are either return statements or break statements in the code.
However, in this codebase, there are "infinite loops" that appear as such until the next line is checked, which is an if statement saying to break if a condition is true.
This unneeded complexity can be resolved by inverting the condition and making that the while-loop condition.
Co-authored-by: pi1024e <[email protected]>
/s/mono2/mono/mini/interp/transform.c:3166:25: note: place parentheses around
the '&&' expression to silence this warning
if (mt >= MINT_TYPE_I1 && mt <= MINT_TYPE_I4
~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
Kind of a silly warning.
mono/sgen/sgen-protocol-def.h:102:1: warning: adding 'unsigned long' to
a string does not append to the string [-Wstring-plus-int]
BEGIN_PROTOCOL_ENTRY_HEAVY2 (binary_protocol_block_alloc, TYPE_POINTER, addr, TYPE_SIZE, size)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
tools/sgen/sgen-grep-binprot.c:394:2: note: expanded from macro
'BEGIN_PROTOCOL_ENTRY_HEAVY2'
BEGIN_PROTOCOL_ENTRY2 (method,t1,f1,t2,f2)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
tools/sgen/sgen-grep-binprot.c:291:26:
note: BEGIN_PROTOCOL_ENTRY3 (binary_protocol_world_stopping,
TYPE_INT, generation, TYPE_LONGLONG, timestamp, TYPE_POINTER, thread)exp
mono/sgen/sgen-protocol-def.h:102:1: note: use array indexing to
silence this warning
This is subtle and not actually misleading,
because it tends to be space tab or space tab, not wrong
number of tabs or significant wrong number of spaces.
/s/mono2/mono/metadata/class.c:4010:6: warning: misleading indentation;
statement is not part of the previous 'if' [-Wmisleading-indentation]
if (mono_class_implement_interface_slo...
/s/mono2/mono/metadata/class.c:4039:3: warning: misleading indentation;
statement is not part of the previous 'if' [-Wmisleading-indentation]
if (m_class_is_delegate (target) && mono_class_has_variant_gener...
/s/mono2/mono/mini/driver.c:1780:4: warning: misleading indentation; statement
is not part of the previous 'if' [-Wmisleading-indentation]
if (strncmp (argv [i], "--debugger-agent=", 17) == 0) {
This just handles systems (mac) without realpath installed and with a version of bash
that doesn't support &>>. It also trims path information from the benchmark name
Current implementation embedded critical runtime information directly
into PLT slot. It also depends on finding call site in generic trampoline
reading call target from instruction stream in order to locate PLT slot
in use and then read GOT offset as well as PLT info offset from PLT slot
instruction stream.
This is problematic on platforms where code is execute only. Fix changes
how the metadata needed in order to correctly patch PLT is discovered.
Instead of depending on reading instruction stream, it is loaded into
RAX (free to be used when calling through PLT on AMD64) in PLT slot
before jmp takes place that moves control over to generic trampoline.
The PLT slot is the only place where we have access to both GOT index
(used in jmp), PLT info offset (currently embedded after jmp instruction)
and emitted PLT slot index. Since PLT slot index can be used to recover
GOT offset used by PLT slot as well as PLT info offset at runtime,
PLT slot index will be emitted into instruction stream and loaded into
RAX (prepared to be configurable to other reg if needed) before doing the
jump over to generic trampoline. Size of emitted imm constant is optimized
based on number of total PLT slots used in image, meaning that 1, 2, or 4
bytes could be used to store PLT slot index as an imm constant in
instruction stream. The additional jmp should have minimal to no
performance overhead since it should complete within 1 cycle, reading
imm constant from instruction stream that shouldn’t incur additional
cache misses and sine there is no data dependency between mov and jmp,
there should be options to pipeline both instructions. Since mov has
smaller latency than indirect jmp, mov should be complete once control
gets into the generic tramp (if pipelined).
In order to resolve plt info offset at runtime, needed information is
now emitted as part of got_info_offsets, increase table with 4 bytes/plt
slot, same size currently emitted into the PLT slot instruction stream.
Code size of PLT slot is currently 10 bytes (6 bytes jmp and 4 byte PLT
info offset). Since PLT info offset has been moved into got_info_offset
table, size of PLT slot will be 2, 4, 5 byte mov (depending on needed imm
size) and 6 bytes jmp instruction. As an example, mscorlib can emit all
its PLT slots using 2 byte imm constant, meaning that the PLT slot will
still be 10 bytes, but since PLT info offset of 4 bytes is moved into
got_info_offset, total image increase will be 4 bytes/PLT slot. This is
however still cheaper than alternatives that would burn 1 trampoline/PLT
slot (at least 10 additional bytes/slot) or setup lookup tables in image
or calculate more info at runtime, all-consuming more memory in total.
Note, using this approach is optional and runtime needs to be built using
MONO_ARCH_CODE_EXEC_ONLY in order to enable it since it’s only an opt in
features on platforms that can't read from instructions stream.
Current implementation is AMD64 only, but same pattern could be applied
to other architectures when needed.
* Add generic OP_XOP opcodes for opcodes which the JIT doesn't care about.
Add a SimdOp enum to list the operations performed by these opcodes.
* Add a SimdIntrinsic struct so the mapping between the .net methods
and the JIT opcodes can be specified declaratively.
* Add all intrinsics from the Sse class.
Co-authored-by: vargaz <[email protected]>
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
* [wasm] Convert MonoString to string without utf8
Previously when converting strings from mono objects to js we used a utf8 intermediate buffer, this change builds the js string from the mono string without an intermediate.
* Remove redundant mono_gc_collect during domain unload
Ifdef out mono_gc_collect when Boehm GC is present as it doesn't use remsets
* Fix trailing whitespace
Co-authored-by: Rares Sebastian Popa <[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.
Addresses https://github.com/mono/mono/issues/19005
* [llvm] Move intrinsics definitions into a template header file llvm-intrinsics.h.
* [llvm] Add a call_intrins () helper function.
* [llvm] Add globals for the SSE vector types to make code more compact.
* [llvm] Refactor the registration and lookup of intrinsics.
* Use the Intrinsics class from LLVM to register intrinsics.
* Identify intrinsics using an id instead of their name.
* Disable the wasm intrinsics on older llvm versions.
* Simplify mono_llvm_register_overloaded_intrinsic ().
numOperands is an unsigned integer. In addition, getArgOperand has unsigned int arguments. As a result, I have no idea why i is an int, but to fix compiler warnings, I made it an unsigned int.
Co-authored-by: pi1024e <[email protected]>
As analysed by @jstedfast and me the only way to get this exception with this callstack below is 2 threads call GetThreads at same time, so while one of them is filling the items in the array, the other one is already trying to use the array with null items.
```
System.NullReferenceException: Object reference not set to an instance of an object
at Mono.Debugging.Soft.SoftDebuggerSession.GetId (Mono.Debugger.Soft.ThreadMirror thread) [0x00000] in /Users/runner/runners/2.164.6/work/1/s/monodevelop/main/external/debugger-libs/Mono.Debugging.Soft/SoftDebuggerSession.cs:3227
at Mono.Debugging.Soft.SoftDebuggerSession.OnGetThreads (System.Int64 processId) [0x0002c] in /Users/runner/runners/2.164.6/work/1/s/monodevelop/main/external/debugger-libs/Mono.Debugging.Soft/SoftDebuggerSession.cs:879
at Mono.Debugging.Soft.SoftDebuggerSession.GetThread (Mono.Debugging.Client.ProcessInfo process, Mono.Debugger.Soft.ThreadMirror thread) [0x00008] in /Users/runner/runners/2.164.6/work/1/s/monodevelop/main/external/debugger-libs/Mono.Debugging.Soft/SoftDebuggerSession.cs:902
at Mono.Debugging.Soft.SoftDebuggerSession.HandleBreakEventSet (Mono.Debugger.Soft.Event[] es, System.Boolean dequeuing) [0x00501] in /Users/runner/runners/2.164.6/work/1/s/monodevelop/main/external/debugger-libs/Mono.Debugging.Soft/SoftDebuggerSession.cs:2038
at Mono.Debugging.Soft.SoftDebuggerSession.HandleEventSet (Mono.Debugger.Soft.EventSet es) [0x0005b] in /Users/runner/runners/2.164.6/work/1/s/monodevelop/main/external/debugger-libs/Mono.Debugging.Soft/SoftDebuggerSession.cs:1687
at Mono.Debugging.Soft.SoftDebuggerSession.EventHandler () [0x0005d] in /Users/runner/runners/2.164.6/work/1/s/monodevelop/main/external/debugger-libs/Mono.Debugging.Soft/SoftDebuggerSession.cs:1625
```
PR on mono/debugger-libs -> https://github.com/mono/debugger-libs/pull/300
Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1070384/
Should fix https://github.com/mono/mono/issues/19115. This bug was
introduced in https://github.com/mono/mono/pull/18824, which
conditionally initalized an LLVM JIT-related TLS slot while preserving
unconditonal stores to that same slot.
The value stored in this TLS slot should only be used during JIT
compilation, so set/reset it in `mono_llvm_compile_method` instead of
during IR construction in `mono_llvm_emit_method`. No non-JIT code
should depend on the existence or presence of this TLS variable, so
remove `mono_llvm_jit_set_tls_cfg`.
Try to follow CDP ordering constraints by not responding Debugger.enable until
we've fired scriptParsed events for any already loaded assemblies.
Send Debugger.scriptParsed asynchronously as we load assemblies instead of
waiting for them all to load first and fix some of the sequence point processing
to speed up debugger initialization time.
Rework breakpoint request handling by always passing the request to the browser
then storing both the request and the resultant id for use in when any new scripts
are loaded.
Pass any previous breakpoint requests to the new execution context on page reload.
This cleans up three components of assembly loading that could potentially cause races/crashes.
First, both `add_assemblies_to_domain` and `add_assembly_to_alc` now ignore resolved references on netcore. We were seeing a crash on CI related to an assertion in here that resulted from two threads using the same MonoImage simultaneously as one is being loaded in with LoadFile, and this should solve that. Fixesdotnet/runtime#2305
Second, we take both the domain and ALC loaded assemblies locks simultaneously around the assembly being added to both lists, ensuring they stay in sync.
Finally, MonoImage now takes the image lock when writing to references instead of using the global `assemblies_mutex` in assembly.c for all images. This potentially helps reduce contention. Work here is not complete, but for this PR it's good enough. See dotnet/runtime#32889
Co-authored-by: Ryan Lucia <[email protected]>
In a current shipping Visual C++, 19.21.27702.2,
there is a bug involving const member data in structs, where for example:
static const struct a { // const on this line in either case
const int b; // const on this line
} c = {1};
will have a static initializer, run usually reliably before main, but:
static const struct a { // const on this line in either case
int b; // no const on this line
} c = {1};
will not.
The semantic difference is minuscule, so much so, that the first form
is relatively rare, and the bug shipped.
Just always use the second form.
The difference is that if you have a non-const a, b is still const, I guess.
If you have a const a, then no difference.
You can find these easily:
cd ...
for %a in (*.exe *.dll) do link /dump /disasm %a > %a.txt
findstr /c:"dynamic initializer" *.txt
Which could be automated and tested in CI.
This probably not an actual problem, but it is needlessly inefficient,
and potentially a problem. The timing/ordering of the initializers
is a bit not deterministic. You get writable data where you expect
read only.
It is in fact a compiler bug, fixed in later releases.
But it has been shipping for a while, I first noticed it over two years
ago, in code of mine that it caused to not work (a delayload implementation
which runs before main).
It should now validate against ICollection or any other type that has a Count property for that matter.
We're still relying on the reference source implementation because corefx strips some types out.
Fixes https://github.com/mono/mono/issues/19022
@vargaz noticed I used an incorrect opcode for ConvertScalarToVector128*
I will add a sort of fuzzy tests later (which use all kind of SRI APIs and compare results with CoreCLR) something like this: https://github.com/mono/mono/blob/master/netcore/tests/HwIntrinsics/Program.cs
Also, add signed version of ConvertScalarToVector128*.
Co-authored-by: Egor Bogatov <[email protected]>
Changes done in object-offsets.h adding offsets for TARGET_AMD64 exposed
a build configuration error in the Mono Tool MSVC debug build due to
incorrectly setting both X86 and AMD64 defines causing compile errors
when including object-offset.h. Release configuration didn't have this
configuration error, meaning that CI builds wouldn't trigger build error.
Fix makes sure all MSVC build configurations for Mono Tools
(genmdesc, monodis, pedump) matches the build configuration for other
binaries and that debug build configuration is inline with release build
configuration.
* [aot] Rename acfg->opts to acfg->jit_opts.
* [aot] Add support for emitting the method address table as a table of normal pointers in the data segment.
* [amd64] Obtain the trampoline argument in the generic_trampoline in the AOT case without decoding the call instruction.
* [amd64] Unify the aot specific trampolines so they have the same size/layout, so its easier to compute the address before the call.
For now we only implement intrinsics used by corlib internally to optimize code.
Fixes https://github.com/dotnet/runtime/issues/32510 crash.
`ConvertScalarToVector128UInt32/64` is expanded into LLVM's `insertelement`
`ConvertToUInt32/64` is expanded into LLVM's `extractelement`
Co-authored-by: Egor Bogatov <[email protected]>
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.
Co-authored-by: Ryan Lucia <[email protected]>
I don't think you can create a root domain without reaching the thread info attach call, so this should be safe to change outright.
Fixesdotnet/runtime#32177
We should complete https://github.com/mono/mono/issues/18915 and then convert over other locks as needed, but this fixes the immediate CI hang.
Co-authored-by: Ryan Lucia <[email protected]>
Subject to configuration, spawn has three widely divergent behaviors:
succeed but do nothing
print and exit
do what it sounds like
Rather than mislead the callers, provide only option 3 and let the caller decide what to do otherwise.
PNSE coverage of wasm bcl has shown that only three public members of `System.Net.NetworkInformation.NetworkInterface` class throw `PlatformNotSupportedException`.
Now all public members throw PNSE on WASM.
Relates to https://github.com/mono/mono/issues/18735
Co-authored-by: monojenkins <[email protected]>
* [runtime] Use pointer size gchandles
This would enable in the future to use CoreCLR's GC with mono. This doesn't change the current embedding api, but, in the future, we will end up aligning with coreclr on an embedding api that uses pointer sized gchandles.
* [gc] Change format of gchandles to be netcore compatible
On netcore, the GCHandle class assumes the lowest bit to be usable, for perf improvements. Move the responsability to have this bit available down to the GC implementation, since for CoreCLR GC we shouldn't do any shifting above the gc interface.
* [wasm][debug] use console.trace instead to init runtime
Using a `debugger` breakpoint in Mono.mono_wasm_runtime_ready has
unfortunate side effects, this changes the logic to use console.trace
and checks the stackTrace when the event is arrives.
* add a console.trace stub to runtime-test.js
* Use console.debug with a magic number instead
If LLVM build is done using different build configuration, Mono build
will fail to static link LLVM libraries due to incompatibility between
release and debug C++ runtime library, generating a lot of linker errors
like this:
error LNK2038: mismatch detected for 'RuntimeLibrary':
value 'MD_DynamicRelease' doesn't match value 'MDd_DynamicDebug'
in mini-llvm-cpp.obj
error LNK2038: mismatch detected for '_ITERATOR_DEBUG_LEVEL':
value '0' doesn't match value '2' in mini-llvm-cpp.obj
This is normally not a problem when doing local builds of LLVM but
when using an external provided build, like netcore Mono build,
this problem is more likely to occur.
This fix adds an additional check to make sure build configuration reported
by llvm-config.exe --build-mode matches current Mono build configuration
and if not give a more specific msbuild error:
error : LLVM build Configuration=Release doesn't match current Mono
build Configuration=Debug
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`.
* [wasm][debugger] Always pass failed breakpoint requests to target
Originally we had a simple way to detect that breakpoints were
meant for the runtime but that is no longer true. Now if we
can't location a breakpoint we need to pass the request on to the
target so it can make an attempt.
* Fix test byUrl is a logical breakpoint and should not fail
Currently, the Mono WebAssembly debug proxy logic is treated as "shared source" with ASP.NET Core. Each time we update by copying the sources from this repo into the ASP.NET Core repo, we need to make some updates to avoid problems. The intention of this PR is to make the updates here at source, so we can simply copy the sources as-is and don't need to update them each time.
The changes are:
Making everything internal, since this is not intended as public API surface for ASP.NET Core developers. It's an internal implementation detail of the framework.
To retain convenience for the ProxyDriver and Mono test code, this PR also adds a simple public entrypoint called DebuggerProxy. This exposes nothing except the ability to connect a debugger proxy instance to a websocket. In the ASP.NET Core code, we'll simply omit this file since it's not needed, but even if we did get it in the future when the proxy feature is published as a package, it would still be fine since it doesn't expose any public API that would be expensive to support and maintain.
Replacing all the Console.WriteLine calls with use of ILogger from the standard Microsoft.Extensions.Logging package, as used by most .NET Core-based application frameworks including ASP.NET Core.
This allows external code to control what happens with log output, what severity levels are filtered in/out, etc. In ProxyDriver and Mono test code, I've configured it to behave just like before: it logs to console, and doesn't filter out anything.
This has the benefit that various bits of commented-out logging code no longer need to be commented out. Instead, when calling the logger.Log* methods, each call site can specify a severity level and then (for example) the filter level could be set to Debug so that all Trace items are filtered out by default.
Current hook compares TPA list file names using case sensitive compare. On Windows, the TPA list, when passed from CoreRun.exe makes all file paths lower case, meaning that our checks fails to find assemblies in TPA list.
Since CoreRun.exe is used for both CoreCLR and Mono, removing the tolower on file paths added to the TPA list in CoreRun.exe could be an option, but that might introduce regressions in CoreCLR, so this fix isolate the change to Mono's netcore preload hook.
Co-authored-by: Johan Lorensson <[email protected]>
Adds a basic set of standalone benchmarks from multiple sources, along with simple infrastructure for running them in mono, netcore and node.js wasm. A couple of them also have original JS versions you can run from a JS shell.
When compiling for Mono, Apple's compiler gives a warning saying to put braces around the 0 as it is a subobject. To silence the compiler, I put braces around the 0. Simple fix.
Co-authored-by: pi1024e <[email protected]>
- async local field names don't start with `<`, surface those
- `this` for the actual async method is in a field named like
`<>4__this`, surface it as the `this` object
* [llvm] Remove loaded llvm support, the startup perf penalty doesn't seem to exist any more.
* Fix the windows build.
* Remove more mini-llvm-loaded.c references.
* Remove more --enable-loadedllvm references.
* Make --enable-loadedllvm the same as --enable-llvm.
* Fix run-jenkins.sh.
* Address review comments.
Return address of local (deliberate).
Pointer cast to different size.
Function parameter and declaration badly mismatch (pid_t vs. void*).
Unused locals.
Top level volatile is ignored.
Negative shift undefined.
Call to undeclared function (getpid).
Some are fixed, some are disabled temporarily.
When compiling, Visual Studio gives two compiler warnings in the sysmath.c file about FPILOGB0/-2147483648 being converted into an unsigned integer.
The standard library math.h states that FPILOGB0 be INT_MIN, so I replaced -2147483648 with the INT_MIN macro so the behavior is much more clear as well as stifling the compiler warnings.
Changes tested manually and automatically.
Co-authored-by: pi1024e <[email protected]>
.. breakpoints. Chrome tries set the breakpoints from previous sessions
when the debugger starts up. And we set that in mono, if the runtime is
ready.
But in `MonoProxy.RuntimeReady`, we mark the runtime ready *before*
clearing the breakpoints. So, we end up setting the breakpoints, as
asked by chrome debugger, but then subsequently clearing them!
This manifests as previously set breakpoints in managed code not getting
hit, but if we reset the breakpoint manually then it gets hit.
`mono_wasm_get_var_info` didn't correctly reset the `data.cur_frame`
required for `mono_walk_stack_with_ctx`, as the stack is walked
repeatedly to get the variables.
* [corlib] Invoke TypeBuilderInstantiation.MakeGenericType through a delegate created in the TypeBuilder ctor to break a linker dependency between RuntimeType and TypeBuilderInstantiation.
* [corlib] Update linker descriptor.
* UnmanagedMarshal is not used from native code at all.
* AssemblyName is not used from native code at all.
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.
* [wasm][debugger] Store more per session state and force some event ordering
Register a DebugStore and ExecutionContext per session and force some commands
to block on source loading so that scripts are loaded before attempting to use
them. This should populate the sources in vscode-js-debug properly.
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]>
Correct values fort HighMemoryLoadThresholdBytes, MemoryLoadBytes. I looked in the code for CoreCLR and spoke with Maoni Stephens and Jan Kotas about the values used in CoreCLR, so I am confident they are all correct now.
HighMemoryThresholdBytes is a system wide memory usage threshold at which CoreCLR changes its compaction strategy. There is no direct correspondance to anything in mono-sgen. But since it used by software caches to determine when memory in the system is "nearly" exhauste, mono-sgent will use .9 * total physical memory as an acceptable value.
Co-authored-by: Nathan Ricci <[email protected]>
Code like this:
```
using System;
class Program
{
static byte[] bla = new byte[] {1,2,3,4,5};
static void Main()
{
}
}
```
Compiles to a private field declaration for the array with a compiler generated
name, that name should be quoted if it starts with a digit. For example:
```
IL_0007: ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=5' '<PrivateImplementationDetails>'::'74F81FE167D99B4CB41D6D0CCDA82278CAEE9F3E2F25D5E5A3936FF3DCEC60D0'
```
Fixes https://github.com/mono/mono/issues/18750
1. This wasn't generally conserving the important stack.
2. Larger mechanisms are in place now.
Granted, tuning out rare paths could still be valuable.
A few weird here, esp. for string, but CI passes.
Acknowledged but skipped for now, a request to also refactor the opcode -- it doesn't seem like much throwaway work to go in either order, even if the code is dead (which I don't know).
Also amend recent nonrecursive PR to simulate stack +2 instead of +1.
* [wasm] Improve locals visualization in the debugger
- improves handling of generic types, null objects, delegates
- improves getting the name for nested types, arrays, generic types
top todos from this:
- Remove arity in "foo`2<int, int>" from the type name
- Convert nested type names from `foo/bar` to `foo.bar`.
* [wasm] Fix scoping for `mono_wasm_add_null_var`
- which caused runtime uncaught exceptions
* [wasm] Fix possible lost exception in GetScopeProperties
- An exception, eg., because of an invalid scope id just ends up
uncaught instead of showing up as a failed Result.
* [wasm] Address review feedback
- Replace `stringify_type` with `mono_type_full_name` which does exactly
the same thing!
* [wasm][debugger] Fixup nested class, and generic type names
```
// Fix up generic names like Foo`2<int, string> to Foo<int, string>
// and nested class names like Foo/Bar to Foo.Bar
```
To fix the issue of enabling embedded pdb everywhere the problem was that when the roslyn tests are compiling sources it creates embedded pdb with source file "", and before enable reading the embedded pdb we don't read this information, and now we read and our StackTrace file written in our corlib doesn't expect a source file "", it's okay if it's NULL but not "".
I could fix in corlib or in mono, I prefer to fix on mono because I don't know if there is any other place that doesn't expect source file "".
The test will be moved to XA's `src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/LinkerTests.cs`
It only works if
```xml
<AndroidHttpClientHandlerType>System.Net.Http.MonoWebRequestHandler, System.Net.Http</AndroidHttpClientHandlerType>
```
is set in `Xamarin.Android.Bcl-Tests.csproj` and we don't want it (other tests expect SocketsHttpHandler to be default one). As an alternative we can add it to the `Xamarin.Android.Bcl-Tests.csproj`'s Linker exceptions but `/Xamarin.Android.Build.Tests/Tasks/LinkerTests.cs` is a better place for it.
The real goal is to make it not recursive.
This is just a step along the way.
Note that the actual not-recursive change has *not* yet been developed,
so this *might* amount to nothing useful.
The managed allocator included in a full aot image does not support canaries, leading to inconsistent object layout.
Fixes https://github.com/mono/mono/issues/18925
We never don't track the value of locals who have their address taken in a method, since their value can change without the pass detecting it, leading to propagation of incorrect values. We failed to check for this when doing a stloc.np optimization.
Fixes System.Reflection.Metadata.Tests.ImmutableByteArrayInteropTest.DangerousCreateFromUnderlyingArray
Enable more interp tests, which don't seem to fail on my machine.
This includes some other minor cleanup to the netcore hosting functions.
Setting `assemblies_path` with `APP_PATHS` despite it also being set by `MONO_PATH` doesn't scare me too much because:
1) Anyone using `MONO_PATH` is probably not going through the hosting API and is using `mono-sgen` directly
2) The default host doesn't set `APP_PATHS` (and we've worked fine without it being set at all up until now
3) This is a temporary measure; we will have to refactor our preload hook when we want to properly support the other loader properties anyway
Co-authored-by: Ryan Lucia <[email protected]>
The code is fine, and we should put it back at some point,
but I want things to be clearer regarding https://github.com/mono/mono/issues/18827.
i.e. That this does not cause it.
I don't know what does cause it, granted.
Maybe a preexisting race condition/deadlock, I don't know.
Repro is run a loop like:
```
type \s\1.cmd
for /l %%a in (1 1 999) do echo %%a && C:\s\mono2\msvc\build\sgen\x64\bin\Release\mono-sgen.exe \s\mono2\mono\tests\bug-10127.exe
```
Make MONO_API_DATA clearer, its old form -- MONO_API extern.
extern "C" { } should be added around it not within it, for clarity.
I've always found extern "C" without braces unclear, esp. for data.
i.e.
```
extern "C" {
1 extern void function(); // redundant but clear
// same as void function();
2 extern int data; // not redundant, and clear
}
```
vs.
```
3 extern "C" void function(); // I guess clear.
4 extern "C" int data; // unclear -- is it extern or extern "C" or both?
```
This PR in particular turns 4 into 2.
2 is clearly a declaration, not a definition.
4 is unclear as to if it is a declaration or definition.
I was looking into https://github.com/mono/mono/issues/18827.
This does not actually change anything but makes things clearer.
This is similar/related in spirit to https://github.com/mono/mono/pull/18891.
It should not make a difference.
In this case, `#if __cplusplus` remains, but the meaning of it is clearer.
It becomes *only* about the common `extern "C" { }` and not even the less clear `extern "C"`.
* [interp] Make newobj_vt_fast non-recursive.
* PR feedback: Attempt to provide similer primitive increase_max_stack_height
that is not so roundabout as move_stack (n) + move_stack (-n).
* [interp] Make newobj_vtst_fast not recursive.
This is builds upon https://github.com/mono/mono/pull/18875
and is easiest reviewed after it is merged.
Or, perhaps, this replaces it.
* comment-smithing
* [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.
This wastes about 24 static const bytes which I think is ok.
6 bytes per struct, plus 2 padding, and there are 3 of them.
I was looking into https://github.com/mono/mono/issues/18827
and wanting to rule out #if __cplusplus.
The linker can completely link away some assemblies, but the rest of the ninja
build still requires them. Previously they were generated by running csc, but
thats too slow, so generate them using Cecil from wasm-tuner.
* [llvm] Disable X86 call frame size optimization.
Fixes https://github.com/mono/mono/issues/17285.
For calls that require parameters passed in stack memory,
X86CallFrameOptimization can sometimes replace a sequence of movs to
prologue-reserved stack memory with a sequence of pushes and a compensating sub
rsp after the call. LLVM accumulates an OpAdjustCfaOffset MCCFIInstruction for
each push and and records the ephemeral parameter space consumed by the call
using an OpGnuArgsSize MCCFIInstruction (i.e. DW_CFA_GNU_args_size).
MonoException doesn't support encoding OpGnuArgsSize MCCFIInstructions, and
attempting to encode this instruction can cause unpredictable behavior, due to
our use of llvm_unreachable with assertions disabled [1]. Moreover, even if
MonoException happens to emit valid call frame instructions despite the UB
induced by llvm_unreachable, Mono's exception handler will restore the stack
pointer to the value it contained at the time right before the protected call
instruction was made, without compensating for any ephemeral parameter space.
The stack pointer could be fixed before the jump to the EH handler by
supporting DW_CFA_GNU_args_size or by executing call frame instructions for the
EH handler's frame all the way to the end of the protected instruction address
range--which will include a sub rsp with an appropriate immediate--to determine
an appropriate delta. But it's easier to just disable this optimization. We
already disable it for AOT [2]. It's sometimes disabled by LLVM on Darwin [3].
Also, this commit adds a test (which is a nearly verbatim copy of laszk's
reproduction sample in #17285) for EH failures caused by the interaction of our
EH code and X86CallFrameOptimization.
See also [4], [5], and [6].
[1] https://github.com/dotnet/llvm-project/blob/adeaa08e7bbc9aba5d67cb16c2b348be12deb000/llvm/lib/CodeGen/AsmPrinter/MonoException.cpp#L209-L210
[2] https://github.com/mono/mono/blob/1317cf06da06682419f8f4b0c9810ad5d5d3ac3a/mono/mini/aot-compiler.c#L9872-L9875
[3] https://github.com/dotnet/llvm-project/blob/adeaa08e7bbc9aba5d67cb16c2b348be12deb000/llvm/lib/Target/X86/X86CallFrameOptimization.cpp#L146-L152
[4] https://bugs.llvm.org/show_bug.cgi?id=24792
[5] https://reviews.llvm.org/D13132
[6] http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20151005/304074.html
* Address feedback: add an explanatory comment.
* [jit] Run static cctors for inlined methods, the cctor might not have ran in AOT mode.
* Emit the class init code later since it contains a branch.
* Emit the class init in the first code bblock.
* [abi-details] add explaining comment for macro magic
I think the fallback was added because "let's get it back to work quickly", back in the dark times without CI: https://github.com/mono/mono/commit/b655fb35c61fd3422003de01eed8e634d46b4186
* add constant version. to be used when offset is needed for static array sizes
* missing offset for windows
* windows define fix
mini\mini.c(1253,59): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3100,43): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3273,49): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3281,49): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3480,51): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3490,49): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3626,48): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3664,48): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3722,48): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini.c(3944,47): warning C4390: ';': empty controlled statement found; is this the intent?
mini\mini-runtime.c(549,64): warning C4390: ';': empty controlled statement found; is this the intent?
mini\method-to-ir.c(11838,2): warning C4065: switch statement contains 'default' but no 'case ' labels
metadata\sre.c(2286,11): warning C4309: '=': truncation of constant value
metadata\sre.c(2179,11): warning C4309: '=': truncation of constant value
metadata\sre.c(2204,11): warning C4309: '=': truncation of constant value
metadata\sre.c(2232,11): warning C4309: '=': truncation of constant value
mini\method-to-ir.c(11838,2): warning C4065: switch statement contains 'default' but no 'case
mini\type-checking.c(167,3): warning C4334: '<<': result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
tracing was a mix of:
- sometimes ifdef out, sometimes not; make it always ifdefed
- sometimes int, sometimes gint, sometimes gboolean; make it always int
Much of this PR will end up deleted when the multiple nonrecursive calls are
consolidated, but two will remain -- entry and call: label.
https://github.com/mono/mono/pull/18825 is where this is going but it was deemed
too large and requested to be split up. This is part of it.
https://github.com/mono/mono/pull/18825 was deemed too large so this breaks
it down into smaller pieces.
To consolidate the multiple nonrecursive call sites requires they share the smae
retval variable. Go ahead and share them all.
Fixes
```
fatal error C1083: Cannot open include file: '../../support/libm/complex.c': No such file or directory
```
when `mono-netcore.sln` is opened in vs2019
Also, add `CopyMonoRuntimeFilesFromArtifactsToDestination` target to mono.proj to be able to copy mono runtime bits to any folder (needed for the performance team, cc @fanyang-mono)
Co-authored-by: Egor Bogatov <[email protected]>
https://github.com/mono/mono/pull/18825 was too large.
This starts by replacing imethod with cmethod which is a necessary
part of the consolidation of multiple non-recursive call sites to just one.
* [runtime] Add a few m_method_is_... inline functions.
* [llvmonly] Allow direct calls to tls accessors, its not a problem in llvmonly mode.
* [llvmonly] Allow direct calls to icalls/pinvokes/generic instances in the same module.
* Fix the loaded llvm build.
We currently reuse LLVM's command line parsing system to configure and
enable passes. When using the default code generator pass configuration,
the `ImplicitNullChecks` and `X86CallFrameOptimization` passes can only
be enabled or disabled via the command line argument parser: the
`cl::opt`s controlling these (and many other) passes are private to
their translation units, and `TargetPassConfig`/`X86PassConfig` read
from these `cl::opt`s with no other means to override these values.
Unfortunately, some LLVM command line options have restrictions on the
number of times they may be set, and running the LLVM command line
argument parser more than once can fail, because the 'number of
occurrences' counter is stored in each global `cl::opt`. This causes
several tests to fail--one such test is unhandled-exception-7.cs.
This change:
- removes the lazy LLVM JIT initialization logic and instead
runs this initialization once during `mini_init`,
- moves some stray JIT-only code from mini-llvm.c to llvm-jit.cpp,
- wraps the declarations in domain-internals.h with a
`G_BEGIN_DECLS`/`G_END_DECLS` pair, so that they avoid name
mangling when included in C++ source, and
- removes `exception_cb` and `emitted_cb`: neither were actually used
by live code.
When executing a filter we create a new interp frame, that is a duplicate of the original frame that contains the filter. Once the execution of the filter is finished, we were copying the stack contents back to the base frame. The problem with this is that when the filter is run, the stack is not completely unwinded, meaning that later we can still run a finally block in a frame called by the base frame. This finally block can access the stack arguments, which would reside on the stack of base frame. This means that we must not override the stack of the base frame, only the locals.
Fixes some tests from System.Linq.Expressions suite.
Emit a stub for methods which failed llvm compilation. Currently the stub will
throw a MissingMethodException, later it can fall back to the interpreter etc.
This is required for cross-assembly direct calls, since the caller doesn't
know that the callee has failed llvm compilation leading to missing
symbols during linking.
Fixes MSDN blogs links throughout our docs and source code comments that were broken during the great MSDN migration of 2019.
Note: I am changing the contents of the _davbr Blog Archives_ folder by fixing the broken links. If we need to keep these files exactly as they were when they were copied from the blog, I can revert.
Co-authored-by: Levi Broderick <[email protected]>
* Bump linker submodule
* Use -o instead of -out for linker output
The arguments changed in linker.
Co-authored-by: Alexander Köplinger <[email protected]>
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
Made minor fixes to the preload hook in the process.
The runtime will still crash if you don't specify the TPA paths and include corlib in that list, but it will at least hit an assert that makes clear it can't find corlib instead of attempting to dereference a null pointer in the preload hook.
The monovm header functions are exported for testing purposes, but the file is intentionally not made public as of now.
Co-authored-by: Ryan Lucia <[email protected]>
* [wasm] Avoid compiling release configuration with -s ASSERTIONS=1 in AOT mode, it generates a lot of extra code.
* Update sdks/wasm/packager.cs
Co-Authored-By: Bernhard Urban-Forster <[email protected]>
Co-authored-by: Bernhard Urban-Forster <[email protected]>
Storing uninitialized locals in a managed object shouldn't crash the runtime, so they should be zeroed. This doesn't seem to regress performance on wasm since the initlocals flag is always set, currently. We should be able to remove it most of the time, once we add some multi basic block support to the cprop phase. This will enable us to further reduce call overhead.
Fixes https://github.com/mono/mono/issues/18527
Libgdiplus will fail when attempting to delete a Graphics object
that has an unreleased HDC. This allows Dispose to succeed in
that case.
This more closely resembles the behavior of corefx.
* [interp[wasm] Make newobj_fast not recursive.
This contributes to https://github.com/mono/mono/issues/18646,
and against master might even fix it.
Though much recursion remains in the interpreter/transform.
* [interp] Cleanup redundant code and child_frame vs. frame.
Only the recursive paths need child_frame separate from frame.
Callers of method_entry tended to duplicate parts of it.
Notice it is marked MONO_ALWAYS_INLINE.
And if that isn't right, it should be split into fast and slow forms,
i.e. regarding frame->imethod->transformed.
* Need to EXCEPTION_CHECKPOINT more often -- when transform occurs but does not raise an exception.
* Preserve prior faster paths.
* Making call_vararg added the following to all calls:
storing is_void in a larger scoped local
save is_void
restore is_void
check is_void, along with preexisting check of retval == null
Because retval must be set even for void call_varargs,
because the arglist is found from it.
This removes the check of retval == null, it should be redundant with is_void.
* A little cleaner -- unlikely is in method_entry.
* Comma to make comment easier to read.
Traditionally, Mono is build with native compilers (i.e. "build for this architecture" running in an ARM or ARM64 chroot on an ARM64 server), but to align with CoreCLR, let's go the cross-compile way.
This enables cross-compiler support, by passing a whole bunch of extra info to `./configure`, some of which is set in the common YAML (like the `--sysroot` value)
Co-authored-by: Jo Shields <[email protected]>
This change is motivated on two main fronts. The first is maintainability - the current managed implementation is difficult to understand and I worry diagnosing any potential issues would be a massive time sink. The second is performance - the current implementation appears to suffer from significant lock contention when running the TechEmpower plaintext benchmark. My hope is that the simpler, cleaner native implementation here will avoid both problems, but I don't want to merge it until we have benchmarking data. However, even if the numbers are similar, I still think it's worth merging just from a maintainability perspective.
The native LifoSemaphore implementation has only ever been tested on posix-like platforms, so Windows behavior is unknown. Currently the Windows implementation of LowLevelLifoSemaphore is very different, so unless we have need for the LifoSemaphore elsewhere in the runtime this isn't a concern.
Many thanks to @filipnavara for the initial implementation.
Co-authored-by: Ryan Lucia <[email protected]>
* Use clearer Bash conditionals, since we force Bash anyway
* Add libmono-native.so to bundle
* Add logic to add a etc/mono/config without $mono_libdir to bundle
Mostly resolves: #16991
* [master] Bump msbuild to track xplat-master
* Bump roslyn to 3.5.0-beta3-20111-03 .
* Update nuget.exe to match xbuild
- the closest version available right now, to `5.5.0-rtm.6422` is
`5.5.0-preview2`, so using that for now.
At least on my machine, this is the only warning we have when building netcore in the default configuration.
Co-authored-by: Ryan Lucia <[email protected]>
Mono currently supports a limited subset of **Sse1**-**Sse42** intrinsics used only by CoreLib internally. So once a new API is used to optimize things there we also have to implement it in Mono. So it recently happened in https://github.com/dotnet/runtime/pull/32036 (`Sse2.AddSaturate` was used for the first time).
So this PR implements it for mono (with all Sse2 overloads) using named LLVM intrinsics. It turns out it's different between LLVM6 (we currently based on) and LLVM9 (we plan to migrate to soon).
for `Vector128<byte>` overload it emits
```llvm
%result = call <8 x i16> @llvm.x86.sse2.paddus.b(<16 x i8> %left, <16 x i8> %right)
```
which is then emitted as `vpaddusw`
Co-authored-by: Egor Bogatov <[email protected]>
@@ -1985,6 +1999,11 @@ if test "x$mono_feature_disable_threads" = "xyes"; then
AC_MSG_NOTICE([Disabled threading support])
fi
if test "x$mono_feature_disable_processes" = "xyes"; then
AC_DEFINE(DISABLE_PROCESSES, 1, [Disable process support])
AC_MSG_NOTICE([Disabled process support])
fi
AC_ARG_ENABLE(executables, [ --disable-executables disable the build of the runtime executables], enable_executables=$enableval, enable_executables=yes)
AM_CONDITIONAL(DISABLE_EXECUTABLES, test x$enable_executables = xno)
@@ -2359,14 +2378,6 @@ if test x$host_win32 = xno; then
<!-- Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE file in the project root for more information. -->
<Project Sdk="Microsoft.NET.Sdk">
<!--
This MSBuild file is intended to be used as the body of the default
publishing release pipeline. The release pipeline will use this file
to invoke the PushToStaticFeed task that will read the build asset
manifest and publish the assets described in the manifest to
<!-- Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE file in the project root for more information. -->
<Project Sdk="Microsoft.NET.Sdk">
<!--
This MSBuild file is intended to be used as the body of the default
publishing release pipeline. The release pipeline will use this file
to invoke the PublishSymbols tasks to publish symbols to MSDL and SymWeb.
Parameters:
- PDBArtifactsDirectory : Full path to directory containing PDB files to be published.
- BlobBasePath : Full path containing *.symbols.nupkg packages to be published.
- DotNetSymbolServerTokenMsdl : PAT to access MSDL.
- DotNetSymbolServerTokenSymWeb : PAT to access SymWeb.
- DotNetSymbolExpirationInDays : Expiration days for published packages. Default is 3650.
<!-- Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE file in the project root for more information. -->
<Project Sdk="Microsoft.NET.Sdk">
<!--
This MSBuild file is intended to be used as the body of the default
publishing release pipeline. The release pipeline will use this file
to invoke the SignCheck tool to validate that packages about to
be published are correctly signed.
Parameters:
- PackageBasePath : Directory containing all files that need to be validated.
- SignCheckVersion : Version of SignCheck package to be used.
- SignValidationExclusionList : ItemGroup containing exclusion list to be forwarded to SignCheck.
- EnableJarSigningCheck : Whether .jar files should be validated.
- EnableStrongNameCheck : Whether strong name check should be performed.
-->
<PropertyGroup>
<TargetFramework>netcoreapp2.1</TargetFramework>
</PropertyGroup>
<!--
From 'Signing.props' we import $(SignValidationExclusionList)
echo"By default, the NDK will be downloaded into the cross/android-rootfs/android-ndk-$__NDK_Version directory. If you already have an NDK installation,"
echo"you can set the NDK_DIR environment variable to have this script use that installation of the NDK."
echo"By default, this script will generate a file, android_platform, in the root of the ROOTFS_DIR directory that contains the RID for the supported and tested Android build: android.21-arm64. This file is to replace '/etc/os-release', which is not available for Android."
echo"By default, this script will generate a file, android_platform, in the root of the ROOTFS_DIR directory that contains the RID for the supported and tested Android build: android.28-arm64. This file is to replace '/etc/os-release', which is not available for Android."
exit1
}
__ApiLevel=21# The minimum platform for arm64 is API level 21
__ApiLevel=28# The minimum platform for arm64 is API level 21 but the minimum version that support glob(3) is 28. See $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include/glob.h
__BuildArch=arm64
__AndroidArch=aarch64
__AndroidToolchain=aarch64-linux-android
@@ -53,13 +53,20 @@ for i in "$@"
done
# Obtain the location of the bash script to figure out where the root of the repo is.
Write-PipelineTaskError-Type'warning'-Message"Channel $id is not present in the post-build YAML configuration!"
}
}
Write-Host'done.'
}
catch{
Write-Host$_
Write-PipelineTelemetryError-Category'CheckChannelConsistency'-Message"There was an error while trying to check consistency of Maestro default channels for the build and post-build YAML configuration."
Loaded 100 of 565 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.