* [mono] Fix types for arguments to printf calls

   These came up while I was using a code scanning tool.

* Fix build

Co-authored-by: NJamesNK <JamesNK@users.noreply.github.com>

This is similar in spirit to the static library for the single file host.

The main different from the single file host one is that we don't want `/GL` because the static library is going to be linked on end user machine and `/GL` is super version fragile.

We build two flavors - with control flow guard and without control flow guard. CFG is a compile time option for end users in NativeAOT and we need static libs that support both.

The issue seems to be caused by a bug in the test. The problematic call
to `TestCreateMutex` is passed `nullptr` as the `name` parameter. It
then calls `convert` helper on it to convert it to wide char. However,
the `convert` helper doesn't check whether it is `nullptr` or not and
ends up returning a pointer to a memory with possibly random data,
that is returned by `malloc(0)`. The returned pointer is then passed to
the CreateMutex PAL api that probably ends up attempting to get the
length of the name or something. And depending on the random data, it
sometimes fails.

The fix is to change the `convert` function to handle `nullptr` so that
it returns `nullptr` too.

Tracking: #62423

Fixing regression for AuthType.Anonymous  which leads to a NullReferenceException be thrown. (#62807)

This group comprises a C# & IL main module and a C# & IL library
and tries all four pairings between them. The C# version of the
main module used to be shared but that's problematic with test
merging as distinguishing the two tests with an identical
namespace, class name and entry point would be hard. As this is
the only occurrence of this pattern in the runtime test source
tree, I'm proposing to duplicate the C# main module source and
adjust it for the two scenarios (targeting C# vs. IL version
of the dependent library).

Thanks

Tomas

Co-authored-by: Ndotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

- The page size is different between arm64 processes and emulated x64 processes
- The shared memory file size is set to the page size and there was a strict check on the file size, leading to an exception from the second process of a different arch that tries to share the same mutex
- Made the file size check less strict, and allowed an arch to increase but not decrease the file size such that it can be mapped at page size granularity
- Fix for https://github.com/dotnet/runtime/issues/62140 in main

Co-authored-by: NJames Newton-King <james@newtonking.com>

I have identified 63 tests in the tree that set IlasmRoundTrip
to true in their MSBuild project scripts. I haven't found any place
in the scripts that would be looking at the value so I'm guessing
it may have been a predecessor to today property
IlasmRoundTripIncompatible and I'm proposing to delete the unused
property. Please let me know if you're aware of any test script logic
that queries it.

Thanks

Tomas

The top level `Directory.Build.props` imports eng/native/naming.props,
which defines platform specific naming conventions. Use that in places
where locally defined props are used and delete the redundant props.

* removed IMAGE_MAPPED

* removed RawImageLayout

* delete MappedImageLayout

* use mem-mapping on Windows

* tweaks and touchups

* a few cleanups

* comments

* move EnsureLoaded into Assemby::Init

* A fix for IsDynamic() case.

* fix for preferred base, if used.

* disable failing scenario

* PR feedback

* Typo (CENTINEL --> SENTINEL)

* added a bug link to a disabled test scenario + couple comment tweaks

- eliminate slow ArgsMarshalString
- make rollup build incremental
- exclude dotnet.d.ts from typescript inputs

* Remove AOT warnings for S.Drawing.Common
- `Marshal.SizeOf(Type)` replaced with `Marshal.SizeOt<T>()`
- `Marshal.PtrToStructure(IntrPtr, Type)` replaced with `Marshal.PtrToStructure<T>(IntPtr)`

* Use pointers where possible

* Ref return PRINTDLG

* Use GeneratedDllImport
Co-authored-by: NJan Kotas <jkotas@microsoft.com>

* Avoiding assert on mono runtime

* Update src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
Co-authored-by: NAnkit Jain <radical@gmail.com>

* Addressing @radical comments.
Removing unused fields in another test case.
Co-authored-by: NAnkit Jain <radical@gmail.com>

* [tests] Re-enable some explicit layout tests on Mono

   These were fixed by https://github.com/dotnet/runtime/pull/61467

   Related to https://github.com/dotnet/runtime/issues/36112

* objref and non-objref overlap tests expected to fail AOT compilation

   As well as the NestedStructs tests.

   Resolves https://github.com/dotnet/runtime/issues/62567

- fix require, just capture require on top level, replace it later
- simplify exit, quit
- whitespace in *.lib.*

* Removing trailing dot from a SNI host in TLS

* Add SSL connection scenario for FQDN with trailing dot

* Removing http layer test for FQDN with trailing dot

* Removing null-forgiving for TargetHost

Adds support for running runtime tests in NativeAOT configuration. It's similar to crossgen2 testing, but there's small differences.

* A layout for the AOT compiler is generated into `CORE_ROOT`. This includes the AOT compiler, NativeAOT corelib, and framework/test dependencies we otherwise dump into `CORE_ROOT`.
* The test execution script is amended to first AOT compile the test using the AOT compiler in `CORE_ROOT` and then run the AOT compiled test.
* The test is compiled by running MSBuild on a generated project file. This is different from crossgen2 testing that directly invokes crossgen2. The extra project file is annoying, but also the NativeAOT compiler has more command line arguments and we also need to invoke the platform linker with another set of command line arguments. Having MSBuild do that for us (using the shipping .target/.props that ship with NativeAOT) saves a some trouble there.
* This also includes support for multimodule testing (where each managed .dll is compiled into a single .o/.obj that we link with the native linker). This needs an extra step during test build to precompile the entire framework into a .a/.lib file.

* Generalize loop pre-header creation and loop hoisting

A loop pre-header is a block that flows directly (and only) to the loop entry
block. The loop pre-header is the only non-loop predecessor of the entry block.
Loop invariant code can be hoisted to the loop pre-header where it is
guaranteed to be executed just once (per loop entry).

Currently, a loop pre-header has a number of restrictions:
- it is only created for a "do-while" (top entry) loop, not for a mid-loop entry.
- it isn't created if the current loop head and the loop entry block are in
different EH try regions

Additionally, partially due those restrictions, loop hoisting has restrictions:
- it requires a "do-while" (top entry) loop
- it requires the existing `head` block to dominate the loop entry block
- it requires the existing `head` block to be in the same EH region as the entry block
- it won't hoist if the `entry` block is the first block of a handler

This change removes all these restrictions.

Previously, even if we did create a pre-header, the definition of a pre-header
was a little weaker: an entry predecessor could be a non-loop block and also
not the pre-header, if the predecessor was dominated by the entry block. This
is more complicated to reason about, so I change the pre-header creation to
force entry block non-loop predecessors to branch to the pre-header instead.
This case only rarely occurs, when we have what looks like an outer loop back
edge but the natural loop recognition package doesn't recognize it as an outer loop.

I added a "stress mode" to always create a loop pre-header immediately after
loop recognition. This is disabled currently because loop cloning doesn't
respect the special status and invariants of a pre-header, and so inserts
all the cloning conditions and copied blocks after the pre-header, triggering
new loop structure asserts. This should be improved in the future.

A lot more checking of the loop table and loop annotations on blocks has been
added. This revealed a number of problems with loop unrolling leaving things
in a bad state for downstream phases. Loop unrolling has been updated to fix
this, in particular, the loop table is rebuilt if it is detected that we unroll
a loop that contains nested loops, since there will now be multiple copies of
those nested loops. This is the first case where we might rebuild the loop
table, so it lays the groundwork for potentially rebuilding the loop table in
other cases, such as after loop cloning where we don't add the "slow path"
loops to the table.

There is some code refactoring to simplify the "find loops" code as well.

Some change details:
- `optSetBlockWeights` is elevated to a "phase" that runs prior to loop recognition.
- LoopFlags is simplified:
	- LPFLG_DO_WHILE is removed; call `lpIsTopEntry` instead
	- LPFLG_ONE_EXIT is removed; check `lpExitCnt == 1` instead
	- LPFLG_HOISTABLE is removed (there are no restrictions anymore)
	- LPFLG_CONST is removed: check `lpFlags & (LPFLG_CONST_INIT | LPFLG_CONST_LIMIT) == (LPFLG_CONST_INIT | LPFLG_CONST_LIMIT)` instead (only used in one place
	- bool lpContainsCall is removed and replaced by LPFLG_CONTAINS_CALL
- Added a `lpInitBlock` field to the loop table. For constant and variable
initialization loops, code assumed that these expressions existed in the
`head` block. This isn't true anymore if we insert a pre-header block.
So, capture the block where these actually exist when we determine that
they do exist, and explicitly use this block pointer where needed.
- Added `fgComputeReturnBlocks()` to extract this code out of `fgComputeReachability` into a function
- Added `optFindAndScaleGeneralLoopBlocks()` to extract this out of loop recognition to its own function.
- Added `optResetLoopInfo()` to reset the loop table and block annotations related to loops
- Added `fgDebugCheckBBNumIncreasing()` to allow asserting that the bbNum
order of blocks is increasing. This should be used in phases that depend
on this order to do bbNum comparisons.
- Add a lot more loop table validation in `fgDebugCheckLoopTable()`

* Inline fgBuildBlockNumMap to allow using _alloca

* Fix BBJ_SWITCH output

1. Change `dspSuccs()` to not call code that will call `GetDescriptorForSwitch()`
2. Change `GetDescriptorForSwitch()` to use the correct max block number while
inlining. We probably don't or shouldn't call GetDescriptorForSwitch while inlining,
especially after (1), but this change doesn't hurt.

* Remove incorrect assertion

There was an assertion when considering an existing `head` block as
a potential pre-header, that the `entry` block have the `head`
block as a predecessor. However, we early exit if we find a non-head,
non-loop edge. This could happen before we encounter the `head` block,
making the assert incorrect. We don't want to run the entire loop just
for the purpose of the assert (at least not here), so just remove the
assert.

* Formatting

* Use `_alloca` instead of `alloca` name

* Convert fgBBNumMax usage

Change:
```
compIsForInlining() ? impInlineInfo->InlinerCompiler->fgBBNumMax : fgBBNumMax
```
to:
```
impInlineRoot()->fgBBNumMax
```

* Code review feedback

1. Added loop epoch concept. Currently set but never checked.
2. Added disabled assert about return blocks always being moved
out of line of loop body.
3. Fixed bug checking `totalIter` after it was decremented to zero
as a loop variable
4. Added more comments on incremental loop block `bbNatLoopNum`
setting.

* Add EH condition when converting head to pre-header

When considering converting an existing loop `head` block to a pre-header,
verify that the block has the same EH try region that we would create
for a new pre-header. If not, we go ahead and create the new pre-header.

to remove more unused fields

There is already a comment that this is necessary, but it is only being
done for x86 tailcalls via jit helper. Do it for normal tailcalls to VSD
as well.

Fix #61486

* Do not perform vector save/restore around call that will never return

* First check if tree is a call

* Use the IsNoReturn() method

Most JIT test projects use the _d, _do, _r and _ro name suffixes
to denote debug vs. non-debug ('release') and non-optimized vs.
optimized runs of the tests, however a smaller number of tests
use a different notation using the prefixes _dbg, _speed_dbg,
_rel and _speed_rel. I propose renaming these projects to
match the suffixes other test projects are using.

Thanks

Tomas

* Make sure the combined field size matches the struct size

* Fix the condition

* Update test and include containHoles condition

It disables System.Security.Cryptography.X509Certificates.Tests.X509StoreTests.RemoveReadOnlyNonExistingDoesNotThrow until #62713 is addressed.

It is unnecessary - we model volatile indirections as mutating
the global heap in value numbering and thus they can only ever
be CSE defs, which is legal in our model (only volatile operations
serve as mutators as per ECMA).

We get some good small diffs this way.

However, the real purpose of this change is making fixing the
incorrect assertions for L-value indirections, which will be
identified by the presence of the GTF_NO_CSE flag, as that is
the only reliable way to detect L-values in the compiler, mostly
zero-diff.

We could venture and add something like a GTF_LVALUE flag (I
think we had one with that very name at some point...), but that
seems very risky - how many a place today forgets about GTF_NO_CSE,
certainly plumbing the new flag through will not be a pleasant, or
good, long-term solution. The proper solution is to delete GT_ASG,
but that,  of course, is not something done in one weekend :), and
it seems bad to leave known silent bad codegen bugs hanging around
in the meantime.

* Fix invalid IR in Span[] import

* Re-enable disabled tests

* ListFacetsChecker fix

* Added  Issue_60543 unit test

* retrigger checks

* Added more unit tests

* Update XmlSchemaSet.Tests.csproj

* TC_SchemaSet_NmTokens enhanced

* TC_SchemaSet_NmTokens test refactoring

Co-authored-by: semyon.chertkov <ngkKNG#xf3>