|
| area-Setup | @MichaelSimons | @NikolaMilosavljevic | Distro-specific (Linux, Mac and Windows) setup packages and msi files |
| area-Single-File | @agocke | @elinor-fung @vsadov | |
| area-Snap | @MichaelSimons | @NikolaMilosavljevic @leecow @MichaelSimons | |
| area-System.Buffers | @jeffhandley | @dotnet/area-system-buffers | |
-| area-System.ClientModel | @terrajobst | @dotnet/fxdc | Bugs and feature requests should go to https://github.com/Azure/azure-sdk-for-net/issues. We don't own the code, but FXDC reviews changes to determine overlap with other `System` concepts. The Azure SDK team will post API updates in this repo for us to review. |
-| area-System.CodeDom | @ericstj | @dotnet/area-system-codedom | |
+| area-System.ClientModel | @jeffhandley | @dotnet/fxdc | Bugs and feature requests should go to https://github.com/Azure/azure-sdk-for-net/issues. We don't own the code, but FXDC reviews changes to determine overlap with other `System` concepts. The Azure SDK team will post API updates in this repo for us to review. |
+| area-System.CodeDom | @jeffhandley | @dotnet/area-system-codedom | |
| area-System.Collections | @jeffhandley | @dotnet/area-system-collections | Excluded:
|
+| area-System.ServiceModel.Syndication | @StephenMolloy | @StephenMolloy @dotnet/Tellurium | |
+| area-System.ServiceProcess | @jeffhandley | @dotnet/area-system-serviceprocess | |
+| area-System.Speech | @jeffhandley | @dotnet/area-system-speech | |
+| area-System.Text.Encoding | @jeffhandley | @dotnet/area-system-text-encoding | |
+| area-System.Text.Encodings.Web | @jeffhandley | @dotnet/area-system-text-encodings-web | |
| area-System.Text.Json | @jeffhandley | @dotnet/area-system-text-json | |
-| area-System.Text.RegularExpressions | @ericstj | @dotnet/area-system-text-regularexpressions | Consultants: @stephentoub |
+| area-System.Text.RegularExpressions | @jeffhandley | @dotnet/area-system-text-regularexpressions | Consultants: @stephentoub |
| area-System.Threading | @mangod9 | @kouvel @vsadov | |
| area-System.Threading.Channels | @jeffhandley | @dotnet/area-system-threading-channels | Consultants: @stephentoub |
| area-System.Threading.RateLimiting | @rafikiassumani-msft | @BrennanConroy @halter73 | |
@@ -141,7 +141,7 @@ Note: Editing this file doesn't update the mapping used by `@dotnet-policy-servi
| area-System.Xml | @jeffhandley | @dotnet/area-system-xml | |
| area-TieredCompilation-coreclr | @mangod9 | @kouvel | |
| area-Tools-ILLink | @agocke | @dotnet/illink | |
-| area-Tools-ILVerification | @JulieLeeMSFT | @BruceForstall @dotnet/jit-contrib | |
+| area-Tools-ILVerification | @JulieLeeMSFT | @dotnet/jit-contrib | |
| area-Tracing-coreclr | @steveisok | @dotnet/area-tracing-coreclr | .NET runtime issues for EventPipe and ICorProfiler |
| area-Tracing-mono | @steveisok | @dotnet/dotnet-diag @thaystg | |
| area-TypeSystem-coreclr | @mangod9 | @davidwrighton @MichalStrehovsky @janvorli @mangod9 | |
diff --git a/docs/coding-guidelines/framework-design-guidelines-digest.md b/docs/coding-guidelines/framework-design-guidelines-digest.md
index d48ecc60727dc2..bb512540d38e20 100644
--- a/docs/coding-guidelines/framework-design-guidelines-digest.md
+++ b/docs/coding-guidelines/framework-design-guidelines-digest.md
@@ -107,7 +107,7 @@ characters.
✓ **DO** name types and properties with nouns or noun phrases.
✓ **DO** name methods and events with verbs or verb phrases. Always give
-events names that have a concept of before and after using the present particle
+events names that have a concept of before and after using the present participle
and simple past tense. For example, an event that is raised before a `Form`
closes should be named `Closing`. An event raised after a `Form` is closed
should be named `Closed`.
diff --git a/docs/coding-guidelines/interop-guidelines.md b/docs/coding-guidelines/interop-guidelines.md
index 8338f4c1d04e23..8f3c9e931b508d 100644
--- a/docs/coding-guidelines/interop-guidelines.md
+++ b/docs/coding-guidelines/interop-guidelines.md
@@ -15,12 +15,6 @@ We have the following goals related to interop code being used in dotnet/runtime
- Ensure maximal managed code reuse across different OS flavors which have the same API but not the same ABI.
- This is the case for UNIX and addressing it is a work-in-progress (see issue #2137 and section on "shims" below.)
-## Submitting Changes
-
-Interop code implicitly defines the native platform dependencies that .NET has. These dependencies are tracked and modeled according to the [Tracking Platform Dependencies design](https://github.com/dotnet/designs/blob/main/accepted/2021/platform-dependencies/platform-dependencies.md). Whenever a PR is submitted that changes interop code, it needs to be reviewed to determine whether a change to the platform dependencies model is required.
-
-By default, any change to `src/libraries/Common/src/Interop` folder will add @dotnet/platform-deps-team as a reviewer. If necessary, update the corresponding `https://github.com/dotnet/core/blob/main/release-notes//runtime-deps.json` file to reflect the dependency change. The scope of dependencies is at the file/package level, not individual functions, so interop changes rarely require an update to the model.
-
## Approach
### Interop type
diff --git a/docs/coding-guidelines/project-guidelines.md b/docs/coding-guidelines/project-guidelines.md
index c6c49bf3e131f5..b6e350f9d9eaf7 100644
--- a/docs/coding-guidelines/project-guidelines.md
+++ b/docs/coding-guidelines/project-guidelines.md
@@ -151,7 +151,7 @@ src\\tests - Contains the test code for a library.
## ref
Reference assemblies are required for any library that has more than one implementation or uses a facade. A reference assembly is a surface-area-only assembly that represents the public API of the library. To generate a reference assembly source file you can use the [GenAPI tool](https://www.nuget.org/packages/Microsoft.DotNet.BuildTools.GenAPI). If a library is a pure portable library with a single implementation it need not use a reference assembly at all. Instructions on updating reference sources can be found [here](https://github.com/dotnet/runtime/blob/main/docs/coding-guidelines/updating-ref-source.md).
-In the ref directory for the library there should be at most **one** `.csproj` that contains the latest API for the reference assembly for the library. That project can contain multiple entries in its `TargetFrameworks` property. Ref projects should use `` for its dependencies.
+In the ref directory for the library there should be at most **one** `.csproj` that contains the latest API for the reference assembly for the library. That project can contain multiple entries in its `TargetFrameworks` property.
### ref output
All ref outputs should be under
@@ -159,11 +159,11 @@ All ref outputs should be under
`bin\$(MSBuildProjectName)\ref\$(TargetFramework)`
## src
-In the src directory for a library there should be only **one** `.csproj` file that contains any information necessary to build the library in various target frameworks. All supported target frameworks should be listed in the `TargetFrameworks` property.
+In the src directory for a library there should be only **one** `.csproj` file that contains any information necessary to build the library for various target frameworks. All supported target frameworks should be listed in the `TargetFramework` or `TargetFrameworks` property.
-All libraries should use `` for all their references to libraries that compose the shared framework of the current .NETCoreApp. That will cause them to be resolved against the locally built targeting pack which is located at `artifacts\bin\microsoft.netcore.app.ref`. The only exception to that rule right now is for partial facades which directly reference System.Private.CoreLib and thus need to directly reference other partial facades to avoid type conflicts.
+Libraries should use `ProjectReference` items to reference live dependencies.
-Other target frameworks than .NETCoreApp latest (i.e. `netstandard2.0`, `net462`, `net8.0`) should use ProjectReference items to reference dependencies.
+`Reference` items should only be used when targeting .NET Framework to reference prebuilt assemblies from the targeting pack and which aren't included by default (i.e. `System.DirectoryServices`). For anything else, `Reference` items should not be used as they are not supported in those frameworks.
### src\ILLink
Contains the files used to direct the trimming tool. See [ILLink files](../workflow/trimming/ILLink-files.md).
diff --git a/docs/coding-guidelines/vectorization-guidelines.md b/docs/coding-guidelines/vectorization-guidelines.md
index ab85676263afd6..9ac773872947a9 100644
--- a/docs/coding-guidelines/vectorization-guidelines.md
+++ b/docs/coding-guidelines/vectorization-guidelines.md
@@ -523,7 +523,7 @@ int ManagedReferencesSum(int[] buffer)
Vector128 sum = Vector128.Zero;
- while (!Unsafe.IsAddressGreaterThan(ref current, ref oneVectorAwayFromEnd))
+ while (Unsafe.IsAddressLessThanOrEqualTo(ref current, ref oneVectorAwayFromEnd))
{
sum += Vector128.LoadUnsafe(ref current);
@@ -561,7 +561,7 @@ do
return ...;
}
-while (!Unsafe.IsAddressLessThan(ref currentSearchSpace, ref searchSpace));
+while (Unsafe.IsAddressGreaterThanOrEqualTo(ref currentSearchSpace, ref searchSpace));
```
It was part of `LastIndexOf` implementation, where we were iterating from the end to the beginning of the buffer. In the last iteration of the loop, `currentSearchSpace` could become a pointer to unknown memory that lied before the beginning of the buffer:
@@ -573,7 +573,7 @@ currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector128 GetILCodeVersions(TargetPointer methodDesc);
+// Return all of the Native code versions for a given ILCodeVersion
+public virtual IEnumerable GetNativeCodeVersions(TargetPointer methodDesc, ILCodeVersionHandle ilCodeVersionHandle);
// Return a handle to the version of the native code that includes the given instruction pointer
public virtual NativeCodeVersionHandle GetNativeCodeVersionForIP(TargetCodePointer ip);
// Return a handle to the active version of the native code for a given method descriptor and IL code version. The IL code version and method descriptor must represent the same method
@@ -132,7 +134,7 @@ IEnumerable ICodeVersions.GetILCodeVersions(TargetPointer m
// CodeVersionManager::GetILCodeVersions
GetModuleAndMethodDesc(methodDesc, out TargetPointer module, out uint methodDefToken);
- ModuleHandle moduleHandle = _target.Contracts.Loader.GetModuleHandle(module);
+ ModuleHandle moduleHandle = _target.Contracts.Loader.GetModuleHandleFromModulePtr(module);
TargetPointer ilCodeVersionTable = _target.Contracts.Loader.GetLookupTables(moduleHandle).MethodDefToILCodeVersioningState;
TargetPointer ilVersionStateAddress = _target.Contracts.Loader.GetModuleLookupMapElement(ilCodeVersionTable, methodDefToken, out var _);
@@ -193,18 +195,18 @@ NativeCodeVersionHandle GetSpecificNativeCodeVersion(MethodDescHandle md, Target
return first;
}
- return FindFirstCodeVersion(rts, md, (codeVersion) =>
+ return FindNativeCodeVersionNodes(rts, md, (codeVersion) =>
{
return codeVersion.MethodDesc == md.Address && codeVersion.NativeCode == startAddress;
- });
+ }).FirstOrDefault(NativeCodeVersionHandle.Invalid);
}
-NativeCodeVersionHandle FindFirstCodeVersion(IRuntimeTypeSystem rts, MethodDescHandle md, Func predicate)
+IEnumerable FindNativeCodeVersionNodes(IRuntimeTypeSystem rts, MethodDescHandle md, Func predicate)
{
// ImplicitCodeVersion stage of NativeCodeVersionIterator::Next()
TargetPointer versioningStateAddr = rts.GetMethodDescVersioningState(md);
if (versioningStateAddr == TargetPointer.Null)
- return NativeCodeVersionHandle.Invalid;
+ yield break;
Data.MethodDescVersioningState versioningState = _target.ProcessedData.GetOrAdd(versioningStateAddr);
@@ -215,14 +217,45 @@ NativeCodeVersionHandle FindFirstCodeVersion(IRuntimeTypeSystem rts, MethodDescH
Data.NativeCodeVersionNode current = _target.ProcessedData.GetOrAdd(currentAddress);
if (predicate(current))
{
- return NativeCodeVersionHandle.OfExplicit(currentAddress);
+ yield return NativeCodeVersionHandle.OfExplicit(currentAddress);
}
currentAddress = current.Next;
}
- return NativeCodeVersionHandle.Invalid;
+ yield break;
+}
+```
+
+### Finding all of the native code versions of an ILCodeVersion for a method descriptor
+
+```csharp
+IEnumerable ICodeVersions.GetNativeCodeVersions(TargetPointer methodDesc, ILCodeVersionHandle ilCodeVersionHandle)
+{
+ if (!ilCodeVersionHandle.IsValid)
+ yield break;
+
+ if (!ilCodeVersionHandle.IsExplicit)
+ {
+ // if the ILCodeVersion is synthetic, then yield the synthetic NativeCodeVersion
+ NativeCodeVersionHandle provisionalHandle = NativeCodeVersionHandle.CreateSynthetic(methodDesc);
+ yield return provisionalHandle;
+ }
+
+ // Iterate through versioning state nodes and return the active one, matching any IL code version
+ Contracts.IRuntimeTypeSystem rts = _target.Contracts.RuntimeTypeSystem;
+ MethodDescHandle md = rts.GetMethodDescHandle(methodDesc);
+ TargetNUInt ilVersionId = GetId(ilCodeVersionHandle);
+ IEnumerable nativeCodeVersions = FindNativeCodeVersionNodes(
+ rts,
+ md,
+ (codeVersion) => ilVersionId == codeVersion.ILVersionId);
+ foreach (NativeCodeVersionHandle nativeCodeVersion in nativeCodeVersions)
+ {
+ yield return nativeCodeVersion;
+ }
}
```
+
### Finding the active native code version of an ILCodeVersion for a method descriptor
```csharp
public virtual NativeCodeVersionHandle GetActiveNativeCodeVersionForILCodeVersion(TargetPointer methodDesc, ILCodeVersionHandle ilCodeVersionHandle);
@@ -247,7 +280,7 @@ bool ICodeVersions.CodeVersionManagerSupportsMethod(TargetPointer methodDescAddr
TypeHandle mt = rts.GetTypeHandle(mtAddr);
TargetPointer modAddr = rts.GetModule(mt);
ILoader loader = _target.Contracts.Loader;
- ModuleHandle mod = loader.GetModuleHandle(modAddr);
+ ModuleHandle mod = loader.GetModuleHandleFromModulePtr(modAddr);
ModuleFlags modFlags = loader.GetFlags(mod);
if (modFlags.HasFlag(ModuleFlags.EditAndContinue))
return false;
diff --git a/docs/design/datacontracts/DacStreams.md b/docs/design/datacontracts/DacStreams.md
index 4ddc1eb84ad3ab..a2da0c4ab1eaf3 100644
--- a/docs/design/datacontracts/DacStreams.md
+++ b/docs/design/datacontracts/DacStreams.md
@@ -54,8 +54,8 @@ Following the EENameStream header, there are CountOfNames entries. Each entry be
``` csharp
string StringFromEEAddress(TargetPointer address)
{
- TargetPointer miniMetaDataBuffAddress = _target.Read(_target.ReadGlobalPointer(Constants.Globals.MiniMetaDataBuffAddress));
- uint miniMetaDataBuffMaxSize = _target.Read(_target.ReadGlobalPointer(Constants.Globals.MiniMetaDataBuffMaxSize));
+ TargetPointer miniMetaDataBuffAddress = _target.Read(_target.ReadGlobalPointer("MiniMetaDataBuffAddress"));
+ uint miniMetaDataBuffMaxSize = _target.Read(_target.ReadGlobalPointer("MiniMetaDataBuffMaxSize"));
// Parse MiniMetadataStream according the the format described above to produce a dictionary from pointer to string from the EENameStream.
// Then lookup in the dictionary, to produce a result if it was present in the table.
diff --git a/docs/design/datacontracts/DebugInfo.md b/docs/design/datacontracts/DebugInfo.md
new file mode 100644
index 00000000000000..034eb3609900ed
--- /dev/null
+++ b/docs/design/datacontracts/DebugInfo.md
@@ -0,0 +1,219 @@
+# Contract DebugInfo
+
+This contract is for fetching information related to DebugInfo associated with native code.
+
+## APIs of contract
+
+```csharp
+[Flags]
+public enum SourceTypes : uint
+{
+ SourceTypeInvalid = 0x00, // To indicate that nothing else applies
+ StackEmpty = 0x01, // The stack is empty here
+ CallInstruction = 0x02 // The actual instruction of a call.
+}
+```
+
+```csharp
+public readonly struct OffsetMapping
+{
+ public uint NativeOffset { get; init; }
+ public uint ILOffset { get; init; }
+ public SourceTypes SourceType { get; init; }
+}
+```
+
+```csharp
+// Given a code pointer, return the associated native/IL offset mapping and codeOffset.
+// If preferUninstrumented, will always read the uninstrumented bounds.
+// Otherwise will read the instrumented bounds and fallback to the uninstrumented bounds.
+IEnumerable GetMethodNativeMap(TargetCodePointer pCode, bool preferUninstrumented, out uint codeOffset);
+```
+
+## Version 1
+
+Data descriptors used:
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| `PatchpointInfo` | `LocalCount` | Number of locals in the method associated with the patchpoint. |
+
+Contracts used:
+| Contract Name |
+| --- |
+| `CodeVersions` |
+| `ExecutionManager` |
+
+Constants:
+| Constant Name | Meaning | Value |
+| --- | --- | --- |
+| IL_OFFSET_BIAS | IL offsets are encoded in the DebugInfo with this bias. | `0xfffffffd` (-3) |
+| DEBUG_INFO_BOUNDS_HAS_INSTRUMENTED_BOUNDS | Indicates bounds data contains instrumented bounds | `0xFFFFFFFF` |
+| EXTRA_DEBUG_INFO_PATCHPOINT | Indicates debug info contains patchpoint information | 0x1 |
+| EXTRA_DEBUG_INFO_RICH | Indicates debug info contains rich information | 0x2 |
+
+### DebugInfo Stream Encoding
+
+The DebugInfo stream is encoded using variable length 32-bit values with the following scheme:
+
+A value can be stored using one or more nibbles (a nibble is a 4-bit value). 3 bits of a nibble are used to store 3 bits of the value, and the top bit indicates if the following nibble contains rest of the value. If the top bit is not set, then this nibble is the last part of the value. The higher bits of the value are written out first, and the lowest 3 bits are written out last.
+
+In the encoded stream of bytes, the lower nibble of a byte is used before the high nibble.
+
+A binary value ABCDEFGHI (where A is the highest bit) is encoded as
+the follow two bytes : 1DEF1ABC XXXX0GHI
+
+Examples:
+| Decimal Value | Hex Value | Encoded Result |
+| --- | --- | --- |
+| 0 | 0x0 | X0 |
+| 1 | 0x1 | X1 |
+| 7 | 0x7 | X7 |
+| 8 | 0x8 | 09 |
+| 9 | 0x9 | 19 |
+| 63 | 0x3F | 7F |
+| 64 | 0x40 | F9 X0 |
+| 65 | 0x41 | F9 X1 |
+| 511 | 0x1FF | FF X7 |
+| 512 | 0x200 | 89 08 |
+| 513 | 0x201 | 89 18 |
+
+Based on the encoding specification, we use a decoder defined originally for r2r dump `NibbleReader.cs`
+
+### Bounds Data Encoding (R2R Major Version 16+)
+
+For R2R major version 16 and above, the bounds data uses a bit-packed encoding algorithm:
+
+1. The bounds entry count, bits needed for native deltas, and bits needed for IL offsets are encoded using the nibble scheme above
+2. Each bounds entry is then bit-packed with:
+ - 2 bits for source type (SourceTypeInvalid=0, CallInstruction=1, StackEmpty=2, StackEmpty|CallInstruction=3)
+ - Variable bits for native offset delta (accumulated from previous offset)
+ - Variable bits for IL offset (with IL_OFFSET_BIAS applied)
+
+The bit-packed data is read byte by byte, collecting bits until enough are available for each entry.
+
+### Implementation
+
+``` csharp
+IEnumerable IDebugInfo.GetMethodNativeMap(TargetCodePointer pCode, bool preferUninstrumented, out uint codeOffset)
+{
+ // Get the method's DebugInfo
+ if (_eman.GetCodeBlockHandle(pCode) is not CodeBlockHandle cbh)
+ throw new InvalidOperationException($"No CodeBlockHandle found for native code {pCode}.");
+ TargetPointer debugInfo = _eman.GetDebugInfo(cbh, out bool hasFlagByte);
+
+ TargetCodePointer nativeCodeStart = _eman.GetStartAddress(cbh);
+ codeOffset = (uint)(CodePointerUtils.AddressFromCodePointer(pCode, _target) - CodePointerUtils.AddressFromCodePointer(nativeCodeStart, _target));
+
+ return RestoreBoundaries(debugInfo, hasFlagByte, preferUninstrumented);
+}
+
+private IEnumerable RestoreBoundaries(TargetPointer debugInfo, bool hasFlagByte, bool preferUninstrumented)
+{
+ if (hasFlagByte)
+ {
+ // Check flag byte and skip over any patchpoint info
+ byte flagByte = _target.Read(debugInfo++);
+
+ if ((flagByte & EXTRA_DEBUG_INFO_PATCHPOINT) != 0)
+ {
+ uint localCount = _target.Read(debugInfo + /*PatchpointInfo::LocalCount offset*/)
+ debugInfo += /*size of PatchpointInfo*/ + (localCount * 4);
+ }
+
+ if ((flagByte & EXTRA_DEBUG_INFO_RICH) != 0)
+ {
+ uint richDebugInfoSize = _target.Read(debugInfo);
+ debugInfo += 4;
+ debugInfo += richDebugInfoSize;
+ }
+ }
+
+ NativeReader nibbleNativeReader = new(new TargetStream(_target, debugInfo, 24 /*maximum size of 4 32bit ints compressed*/), _target.IsLittleEndian);
+ NibbleReader nibbleReader = new(nibbleNativeReader, 0);
+
+ uint cbBounds = nibbleReader.ReadUInt();
+ uint cbUninstrumentedBounds = 0;
+ if (cbBounds == DEBUG_INFO_BOUNDS_HAS_INSTRUMENTED_BOUNDS)
+ {
+ // This means we have instrumented bounds.
+ cbBounds = nibbleReader.ReadUInt();
+ cbUninstrumentedBounds = nibbleReader.ReadUInt();
+ }
+ uint _ /*cbVars*/ = nibbleReader.ReadUInt();
+
+ TargetPointer addrBounds = debugInfo + (uint)nibbleReader.GetNextByteOffset();
+ // TargetPointer addrVars = addrBounds + cbBounds + cbUninstrumentedBounds;
+
+ if (preferUninstrumented && cbUninstrumentedBounds != 0)
+ {
+ // If we have uninstrumented bounds, we will use them instead of the regular bounds.
+ addrBounds += cbBounds;
+ cbBounds = cbUninstrumentedBounds;
+ }
+
+ if (cbBounds > 0)
+ {
+ NativeReader boundsNativeReader = new(new TargetStream(_target, addrBounds, cbBounds), _target.IsLittleEndian);
+ return DoBounds(boundsNativeReader);
+ }
+
+ return Enumerable.Empty();
+}
+
+private static IEnumerable DoBounds(NativeReader nativeReader)
+{
+ NibbleReader reader = new(nativeReader, 0);
+
+ uint boundsEntryCount = reader.ReadUInt();
+
+ uint bitsForNativeDelta = reader.ReadUInt() + 1; // Number of bits needed for native deltas
+ uint bitsForILOffsets = reader.ReadUInt() + 1; // Number of bits needed for IL offsets
+
+ uint bitsPerEntry = bitsForNativeDelta + bitsForILOffsets + 2; // 2 bits for source type
+ ulong bitsMeaningfulMask = (1UL << ((int)bitsPerEntry)) - 1;
+ int offsetOfActualBoundsData = reader.GetNextByteOffset();
+
+ uint bitsCollected = 0;
+ ulong bitTemp = 0;
+ uint curBoundsProcessed = 0;
+
+ uint previousNativeOffset = 0;
+
+ while (curBoundsProcessed < boundsEntryCount)
+ {
+ bitTemp |= ((uint)nativeReader[offsetOfActualBoundsData++]) << (int)bitsCollected;
+ bitsCollected += 8;
+ while (bitsCollected >= bitsPerEntry)
+ {
+ ulong mappingDataEncoded = bitsMeaningfulMask & bitTemp;
+ bitTemp >>= (int)bitsPerEntry;
+ bitsCollected -= bitsPerEntry;
+
+ SourceTypes sourceType = (mappingDataEncoded & 0x3) switch
+ {
+ 0 => SourceTypes.SourceTypeInvalid,
+ 1 => SourceTypes.CallInstruction,
+ 2 => SourceTypes.StackEmpty,
+ 3 => SourceTypes.StackEmpty | SourceTypes.CallInstruction,
+ _ => throw new InvalidOperationException($"Unknown source type encoding: {mappingDataEncoded & 0x3}")
+ };
+
+ mappingDataEncoded >>= 2;
+ uint nativeOffsetDelta = (uint)(mappingDataEncoded & ((1UL << (int)bitsForNativeDelta) - 1));
+ previousNativeOffset += nativeOffsetDelta;
+ uint nativeOffset = previousNativeOffset;
+
+ mappingDataEncoded >>= (int)bitsForNativeDelta;
+ uint ilOffset = (uint)mappingDataEncoded + IL_OFFSET_BIAS;
+
+ yield return new OffsetMapping()
+ {
+ NativeOffset = nativeOffset,
+ ILOffset = ilOffset,
+ SourceType = sourceType
+ };
+ curBoundsProcessed++;
+ }
+ }
+}
+```
diff --git a/docs/design/datacontracts/ECall.md b/docs/design/datacontracts/ECall.md
deleted file mode 100644
index f1ea6c4f8cc07d..00000000000000
--- a/docs/design/datacontracts/ECall.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# Contract ECall
-
-This contract is for fetching information related to native calls into the runtime.
-
-## APIs of contract
-
-``` csharp
-// Given an FCall entrypoint returns the corresponding MethodDesc.
-// If the address does not correspond to an FCall, returns TargetPointer.Null.
-TargetPointer MapTargetBackToMethodDesc(TargetCodePointer address);
-```
-
-## Version 1
-
-Global variables used
-| Global Name | Type | Purpose |
-| --- | --- | --- |
-| FCallMethods | ECHash[] | Hash table containing ECHash structures |
-| FCallHashSize | uint | Number of buckets in the hash table |
-
-
-Data descriptors used:
-| Data Descriptor Name | Field | Meaning |
-| --- | --- | --- |
-| `ECHash` | `Next` | Pointer to the next ECHash in the chain |
-| `ECHash` | `Implementation` | FCall's Entrypoint address |
-| `ECHash` | `MethodDesc` | Pointer to the FCall's method desc |
-
-
-``` csharp
-TargetPointer IECall.MapTargetBackToMethodDesc(TargetCodePointer codePointer)
-```
-
-To map an FCall entrypoint back to a MethodDesc, we read the global `FCallMethods` hash table. This is a array of pointers to `ECHash` objects. The length of this array is defined by the global `FCallHashSize` where each element is an `ECHash` which can form a chain. It uses a simple hash function: ` = codePointer % FCallHashSize` to map code entry points to buckets. To map a `codePointer` back to a MethodDesc pointer:
-
-1. Calculate the `` corresponding to the given `codePointer`.
-2. Take the `` offset into the `FCallMethods` array.
-3. Now that we have the correct `ECHash` chain, iterate the chain using the `ECHash.Next` pointer until we find an `ECHash` where the `Implementation` field matches the `codePointer`. If found, return the `MethodDesc` field.
-4. If no `ECHash` matches return `TargetPointer.Null` to indicate a MethodDesc was not found.
diff --git a/docs/design/datacontracts/ExecutionManager.md b/docs/design/datacontracts/ExecutionManager.md
index 1b5e360f6ec308..103aac455a2a48 100644
--- a/docs/design/datacontracts/ExecutionManager.md
+++ b/docs/design/datacontracts/ExecutionManager.md
@@ -29,6 +29,9 @@ struct CodeBlockHandle
TargetPointer GetUnwindInfo(CodeBlockHandle codeInfoHandle);
// Gets the base address the UnwindInfo of codeInfoHandle is relative to
TargetPointer GetUnwindInfoBaseAddress(CodeBlockHandle codeInfoHandle);
+ // Gets the DebugInfo associated with the code block and specifies if the DebugInfo contains
+ // the flag byte which modifies how DebugInfo is parsed.
+ TargetPointer GetDebugInfo(CodeBlockHandle codeInfoHandle, out bool hasFlagByte);
// Gets the GCInfo associated with the code block and its version
// **Currently GetGCInfo only supports X86**
void GetGCInfo(CodeBlockHandle codeInfoHandle, out TargetPointer gcInfo, out uint gcVersion);
@@ -66,9 +69,11 @@ Data descriptors used:
| `CodeHeapListNode` | `EndAddress` | End address of the used portion of the code heap |
| `CodeHeapListNode` | `MapBase` | Start of the map - start address rounded down based on OS page size |
| `CodeHeapListNode` | `HeaderMap` | Bit array used to find the start of methods - relative to `MapBase` |
+| `EEJitManager` | `StoreRichDebugInfo` | Boolean value determining if debug info associated with the JitManager contains rich info. |
| `RealCodeHeader` | `MethodDesc` | Pointer to the corresponding `MethodDesc` |
| `RealCodeHeader` | `NumUnwindInfos` | Number of Unwind Infos |
| `RealCodeHeader` | `UnwindInfos` | Start address of Unwind Infos |
+| `RealCodeHeader` | `DebugInfo` | Pointer to the DebugInfo |
| `RealCodeHeader` | `GCInfo` | Pointer to the GCInfo encoding |
| `Module` | `ReadyToRunInfo` | Pointer to the `ReadyToRunInfo` for the module |
| `ReadyToRunInfo` | `ReadyToRunHeader` | Pointer to the ReadyToRunHeader |
@@ -78,6 +83,7 @@ Data descriptors used:
| `ReadyToRunInfo` | `NumHotColdMap` | Number of entries in the `HotColdMap` |
| `ReadyToRunInfo` | `HotColdMap` | Pointer to an array of 32-bit integers - [see R2R format](../coreclr/botr/readytorun-format.md#readytorunsectiontypehotcoldmap-v80) |
| `ReadyToRunInfo` | `DelayLoadMethodCallThunks` | Pointer to an `ImageDataDirectory` for the delay load method call thunks |
+| `ReadyToRunInf` | `DebugInfo` | Pointer to an `ImageDataDirectory` for the debug info |
| `ReadyToRunInfo` | `EntryPointToMethodDescMap` | `HashMap` of entry point addresses to `MethodDesc` pointers |
| `ReadyToRunHeader` | `MajorVersion` | ReadyToRun major version |
| `ReadyToRunHeader` | `MinorVersion` | ReadyToRun minor version |
@@ -100,6 +106,7 @@ Global variables used:
| `HashMapValueMask` | uint64 | Bitmask used when storing values in a `HashMap` |
| `FeatureEHFunclets` | uint8 | 1 if EH funclets are enabled, 0 otherwise |
| `GCInfoVersion` | uint32 | JITted code GCInfo version |
+| `FeatureOnStackReplacement` | uint8 | 1 if FEATURE_ON_STACK_REPLACEMENT is enabled, 0 otherwise |
Contracts used:
| Contract Name |
@@ -266,9 +273,16 @@ The `GetMethodDesc`, `GetStartAddress`, and `GetRelativeOffset` APIs extract fie
Unwind info (`RUNTIME_FUNCTION`) use relative addressing. For managed code, these values are relative to the start of the code's containing range in the RangeSectionMap (described below). This could be the beginning of a `CodeHeap` for jitted code or the base address of the loaded image for ReadyToRun code.
`GetUnwindInfoBaseAddress` finds this base address for a given `CodeBlockHandle`.
+`IExecutionManager.GetDebugInfo` gets a pointer to the relevant DebugInfo for a `CodeBlockHandle`. The ExecutionManager delegates to the JitManager implementations as the DebugInfo is stored in different ways on jitted and R2R code.
+
+* For Jitted code (`EEJitManager`) a pointer to the `DebugInfo` is stored on the `RealCodeHeader` which is accessed in the same way as `GetMethodInfo` described above. `hasFlagByte` is `true` if either the global `FeatureOnStackReplacement` is `true` or `StoreRichDebugInfo` is `true` on the `EEJitManager`.
+
+* For R2R code (`ReadyToRunJitManager`) the `DebugInfo` is stored as part of the R2R image. The relevant `ReadyToRunInfo` stores a pointer to the an `ImageDataDirectory` representing the `DebugInfo` directory. Read the `VirtualAddress` of this data directory as a `NativeArray` containing the `DebugInfos`. To find the specific `DebugInfo`, index into the array using the `index` of the beginning of the R2R function as found like in `GetMethodInfo` above. This yields an offset `offset` value relative to the image base. Read the first variable length uint at `imageBase + offset`, `lookBack`. If `lookBack != 0`, return `imageBase + offset - lookback`. Otherwise return `offset + size of reading lookback`.
+For R2R images, `hasFlagByte` is always `false`.
+
`IExecutionManager.GetGCInfo` gets a pointer to the relevant GCInfo for a `CodeBlockHandle`. The ExecutionManager delegates to the JitManager implementations as the GCInfo is stored differently on jitted and R2R code.
-* For jitted code (`EEJitManager`) a pointer to the `GCInfo` is stored on the `RealCodeHeader` which is accessed in the same was as `GetMethodInfo` described above. This can simply be returned as is. The `GCInfoVersion` is defined by the runtime global `GCInfoVersion`.
+* For jitted code (`EEJitManager`) a pointer to the `GCInfo` is stored on the `RealCodeHeader` which is accessed in the same way as `GetMethodInfo` described above. This can simply be returned as is. The `GCInfoVersion` is defined by the runtime global `GCInfoVersion`.
* For R2R code (`ReadyToRunJitManager`), the `GCInfo` is stored directly after the `UnwindData`. This in turn is found by looking up the `UnwindInfo` (`RUNTIME_FUNCTION`) and reading the `UnwindData` offset. We find the `UnwindInfo` as described above in `IExecutionManager.GetUnwindInfo`. Once we have the relevant unwind data, we calculate the size of the unwind data and return a pointer to the following byte (first byte of the GCInfo). The size of the unwind data is a platform specific. Currently only X86 is supported with a constant unwind data size of 32-bits.
* The `GCInfoVersion` of R2R code is mapped from the R2R MajorVersion and MinorVersion which is read from the ReadyToRunHeader which itself is read from the ReadyToRunInfo (can be found as in GetMethodInfo). The current GCInfoVersion mapping is:
@@ -301,6 +315,10 @@ On 64-bit targets, we take advantage of the fact that most architectures don't s
That is, level 5 has 256 entires pointing to level 4 maps (or nothing if there's no
code allocated in that address range), level 4 entires point to level 3 maps and so on. Each level 1 map has 256 entries covering a 128 KiB chunk and pointing to a linked list of range section fragments that fall within that 128 KiB chunk.
+### Native Format
+
+The ReadyToRun image stores data in a compressed native foramt defined in [nativeformatreader.h](../../../src/coreclr/vm/nativeformatreader.h).
+
### NibbleMap
The ExecutionManager contract depends on a "nibble map" data structure
diff --git a/docs/design/datacontracts/Loader.md b/docs/design/datacontracts/Loader.md
index 107e7d5617dfc2..30372f60e6eb71 100644
--- a/docs/design/datacontracts/Loader.md
+++ b/docs/design/datacontracts/Loader.md
@@ -52,9 +52,12 @@ record struct ModuleLookupTables(
```
``` csharp
-ModuleHandle GetModuleHandle(TargetPointer module);
-IEnumerable GetModules(TargetPointer appDomain, AssemblyIterationFlags iterationFlags);
+ModuleHandle GetModuleHandleFromModulePtr(TargetPointer module);
+ModuleHandle GetModuleHandleFromAssemblyPtr(TargetPointer assemblyPointer);
+IEnumerable GetModuleHandles(TargetPointer appDomain, AssemblyIterationFlags iterationFlags);
TargetPointer GetRootAssembly();
+string GetAppDomainFriendlyName();
+TargetPointer GetModule(ModuleHandle handle);
TargetPointer GetAssembly(ModuleHandle handle);
TargetPointer GetPEAssembly(ModuleHandle handle);
bool TryGetLoadedImageContents(ModuleHandle handle, out TargetPointer baseAddress, out uint size, out uint imageFlags);
@@ -67,12 +70,16 @@ ModuleFlags GetFlags(ModuleHandle handle);
string GetPath(ModuleHandle handle);
string GetFileName(ModuleHandle handle);
TargetPointer GetLoaderAllocator(ModuleHandle handle);
-TargetPointer GetThunkHeap(ModuleHandle handle);
TargetPointer GetILBase(ModuleHandle handle);
+TargetPointer GetAssemblyLoadContext(ModuleHandle handle);
ModuleLookupTables GetLookupTables(ModuleHandle handle);
TargetPointer GetModuleLookupMapElement(TargetPointer table, uint token, out TargetNUInt flags);
bool IsCollectible(ModuleHandle handle);
bool IsAssemblyLoaded(ModuleHandle handle);
+TargetPointer GetGlobalLoaderAllocator();
+TargetPointer GetHighFrequencyHeap(TargetPointer loaderAllocatorPointer);
+TargetPointer GetLowFrequencyHeap(TargetPointer loaderAllocatorPointer);
+TargetPointer GetStubHeap(TargetPointer loaderAllocatorPointer);
```
## Version 1
@@ -85,7 +92,6 @@ bool IsAssemblyLoaded(ModuleHandle handle);
| `Module` | `Base` | Pointer to start of PE file in memory |
| `Module` | `Flags` | Assembly of the Module |
| `Module` | `LoaderAllocator` | LoaderAllocator of the Module |
-| `Module` | `ThunkHeap` | Pointer to the thunk heap |
| `Module` | `Path` | Path of the Module (UTF-16, null-terminated) |
| `Module` | `FileName` | File name of the Module (UTF-16, null-terminated) |
| `Module` | `GrowableSymbolStream` | Pointer to the in memory symbol stream |
@@ -107,6 +113,8 @@ bool IsAssemblyLoaded(ModuleHandle handle);
| `Assembly` | `NotifyFlags` | Flags relating to the debugger/profiler notification state of the assembly |
| `Assembly` | `Level` | File load level of the assembly |
| `PEAssembly` | `PEImage` | Pointer to the PEAssembly's PEImage |
+| `PEAssembly` | `AssemblyBinder` | Pointer to the PEAssembly's binder |
+| `AssemblyBinder` | `AssemblyLoadContext` | Pointer to the AssemblyBinder's AssemblyLoadContext |
| `PEImage` | `LoadedImageLayout` | Pointer to the PEImage's loaded PEImageLayout |
| `PEImage` | `ProbeExtensionResult` | PEImage's ProbeExtensionResult |
| `ProbeExtensionResult` | `Type` | Type of ProbeExtensionResult |
@@ -117,7 +125,12 @@ bool IsAssemblyLoaded(ModuleHandle handle);
| `CGrowableSymbolStream` | `Size` | Size of the raw symbol stream buffer |
| `AppDomain` | `RootAssembly` | Pointer to the root assembly |
| `AppDomain` | `DomainAssemblyList` | ArrayListBase of assemblies in the AppDomain |
+| `AppDomain` | `FriendlyName` | Friendly name of the AppDomain |
+| `SystemDomain` | `GlobalLoaderAllocator` | global LoaderAllocator |
| `LoaderAllocator` | `ReferenceCount` | Reference count of LoaderAllocator |
+| `LoaderAllocator` | `HighFrequencyHeap` | High-frequency heap of LoaderAllocator |
+| `LoaderAllocator` | `LowFrequencyHeap` | Low-frequency heap of LoaderAllocator |
+| `LoaderAllocator` | `StubHeap` | Stub heap of LoaderAllocator |
| `ArrayListBase` | `Count` | Total number of elements in the ArrayListBase |
| `ArrayListBase` | `FirstBlock` | First ArrayListBlock |
| `ArrayListBlock` | `Next` | Next ArrayListBlock in chain |
@@ -137,6 +150,7 @@ bool IsAssemblyLoaded(ModuleHandle handle);
| Global Name | Type | Purpose |
| --- | --- | --- |
| `AppDomain` | TargetPointer | Pointer to the global AppDomain |
+| `SystemDomain` | TargetPointer | Pointer to the global SystemDomain |
### Contract Constants:
@@ -159,12 +173,18 @@ private enum ModuleFlags_1 : uint
### Method Implementations
``` csharp
-ModuleHandle GetModuleHandle(TargetPointer modulePointer)
+ModuleHandle GetModuleHandleFromModulePtr(TargetPointer modulePointer)
{
return new ModuleHandle(modulePointer);
}
-IEnumerable GetModules(TargetPointer appDomain, AssemblyIterationFlags iterationFlags)
+ModuleHandle ILoader.GetModuleHandleFromAssemblyPtr(TargetPointer assemblyPointer)
+{
+ Data.Assembly assembly = // read Assembly object at assemblyPointer
+ return new ModuleHandle(assembly.Module);
+}
+
+IEnumerable GetModuleHandles(TargetPointer appDomain, AssemblyIterationFlags iterationFlags)
{
if (appDomain == TargetPointer.Null) throw new ArgumentException("appDomain must not be null");
@@ -263,11 +283,25 @@ IEnumerable GetModules(TargetPointer appDomain, AssemblyIterationF
TargetPointer GetRootAssembly()
{
- TargetPointer appDomainPointer = target.ReadGlobalPointer(Constants.Globals.AppDomain);
+ TargetPointer appDomainPointer = target.ReadGlobalPointer("AppDomain");
AppDomain appDomain = // read AppDomain object starting at appDomainPointer
return appDomain.RootAssembly;
}
+string ILoader.GetAppDomainFriendlyName()
+{
+ TargetPointer appDomainPointer = target.ReadGlobalPointer("AppDomain");
+ TargetPointer appDomain = target.ReadPointer(appDomainPointer)
+ TargetPointer pathStart = appDomain + /* AppDomain::FriendlyName offset */;
+ char[] name = // Read from target starting at pathStart until null terminator
+ return new string(name);
+}
+
+TargetPointer ILoader.GetModule(ModuleHandle handle)
+{
+ return handle.Address;
+}
+
TargetPointer GetAssembly(ModuleHandle handle)
{
return target.ReadPointer(handle.Address + /* Module::Assembly offset */);
@@ -385,14 +419,17 @@ TargetPointer GetLoaderAllocator(ModuleHandle handle)
return target.ReadPointer(handle.Address + /* Module::LoaderAllocator offset */);
}
-TargetPointer GetThunkHeap(ModuleHandle handle)
+TargetPointer GetILBase(ModuleHandle handle)
{
- return target.ReadPointer(handle.Address + /* Module::ThunkHeap offset */);
+ return target.ReadPointer(handle.Address + /* Module::Base offset */);
}
-TargetPointer GetILBase(ModuleHandle handle)
+TargetPointer ILoader.GetAssemblyLoadContext(ModuleHandle handle)
{
- return target.ReadPointer(handle.Address + /* Module::Base offset */);
+ PEAssembly peAssembly = target.ReadPointer(handle.Address + /* Module::PEAssembly offset */);
+ AssemblyBinder binder = target.ReadPointer(peAssembly + /* PEAssembly::AssemblyBinder offset */);
+ ObjectHandle objectHandle = new ObjectHandle(binder);
+ return objectHandle.Object;
}
ModuleLookupTables GetLookupTables(ModuleHandle handle)
@@ -417,40 +454,61 @@ TargetPointer GetModuleLookupMapElement(TargetPointer table, uint token, out Tar
uint index = rid;
// have to read lookupMap an extra time upfront because only the first map
// has valid supportedFlagsMask
- TargetNUInt supportedFlagsMask = _target.ReadNUInt(table + /* ModuleLookupMap::SupportedFlagsMask */);
+ TargetNUInt supportedFlagsMask = target.ReadNUInt(table + /* ModuleLookupMap::SupportedFlagsMask */);
do
{
- if (index < _target.Read(table + /*ModuleLookupMap::Count*/))
+ if (index < target.Read(table + /*ModuleLookupMap::Count*/))
{
- TargetPointer entryAddress = _target.ReadPointer(lookupMap + /*ModuleLookupMap::TableData*/) + (ulong)(index * _target.PointerSize);
- TargetPointer rawValue = _target.ReadPointer(entryAddress);
+ TargetPointer entryAddress = target.ReadPointer(lookupMap + /*ModuleLookupMap::TableData*/) + (ulong)(index * target.PointerSize);
+ TargetPointer rawValue = target.ReadPointer(entryAddress);
flags = rawValue & supportedFlagsMask;
return rawValue & ~(supportedFlagsMask.Value);
}
else
{
- table = _target.ReadPointer(lookupMap + /*ModuleLookupMap::Next*/);
- index -= _target.Read(lookupMap + /*ModuleLookupMap::Count*/);
+ table = target.ReadPointer(lookupMap + /*ModuleLookupMap::Next*/);
+ index -= target.Read(lookupMap + /*ModuleLookupMap::Count*/);
}
} while (table != TargetPointer.Null);
return TargetPointer.Null;
}
-```
-```csharp
-bool ILoader.IsCollectible(ModuleHandle handle)
+bool IsCollectible(ModuleHandle handle)
{
- TargetPointer assembly = _target.ReadPointer(handle.Address + /*Module::Assembly*/);
- byte isCollectible = _target.Read(assembly + /* Assembly::IsCollectible*/);
+ TargetPointer assembly = target.ReadPointer(handle.Address + /*Module::Assembly*/);
+ byte isCollectible = target.Read(assembly + /* Assembly::IsCollectible*/);
return isCollectible != 0;
}
-bool ILoader.IsAssemblyLoaded(ModuleHandle handle)
+bool IsAssemblyLoaded(ModuleHandle handle)
{
- TargetPointer assembly = _target.ReadPointer(handle.Address + /*Module::Assembly*/);
- uint loadLevel = _target.Read(assembly + /* Assembly::Level*/);
+ TargetPointer assembly = target.ReadPointer(handle.Address + /*Module::Assembly*/);
+ uint loadLevel = target.Read(assembly + /* Assembly::Level*/);
return assembly.Level >= ASSEMBLY_LEVEL_LOADED;
}
+
+TargetPointer GetGlobalLoaderAllocator()
+{
+ TargetPointer systemDomainPointer = target.ReadGlobalPointer("SystemDomain");
+ TargetPointer systemDomain = target.ReadPointer(systemDomainPointer);
+ return target.ReadPointer(systemDomain + /* SystemDomain::GlobalLoaderAllocator offset */);
+}
+
+TargetPointer GetHighFrequencyHeap(TargetPointer loaderAllocatorPointer)
+{
+ return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::HighFrequencyHeap offset */);
+}
+
+TargetPointer GetLowFrequencyHeap(TargetPointer loaderAllocatorPointer)
+{
+ return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::LowFrequencyHeap offset */);
+}
+
+TargetPointer GetStubHeap(TargetPointer loaderAllocatorPointer)
+{
+ return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::StubHeap offset */);
+}
+
```
### DacEnumerableHash (EETypeHashTable and InstMethodHashTable)
diff --git a/docs/design/datacontracts/PrecodeStubs.md b/docs/design/datacontracts/PrecodeStubs.md
index 83f593fcf2c0ad..b336b433ac2e13 100644
--- a/docs/design/datacontracts/PrecodeStubs.md
+++ b/docs/design/datacontracts/PrecodeStubs.md
@@ -9,22 +9,32 @@ This contract provides support for examining [precode](../coreclr/botr/method-de
TargetPointer GetMethodDescFromStubAddress(TargetCodePointer entryPoint);
```
-## Version 1 and 2
+## Version 1, 2, and 3
Data descriptors used:
| Data Descriptor Name | Field | Meaning |
| --- | --- | --- |
-| PrecodeMachineDescriptor | OffsetOfPrecodeType | See `ReadPrecodeType` |
-| PrecodeMachineDescriptor | ShiftOfPrecodeType | See `ReadPrecodeType` |
-| PrecodeMachineDescriptor | ReadWidthOfPrecodeType | See `ReadPrecodeType` |
+| PrecodeMachineDescriptor | OffsetOfPrecodeType | See `ReadPrecodeType` (Version 1 and 2 only) |
+| PrecodeMachineDescriptor | ShiftOfPrecodeType | See `ReadPrecodeType` (Version 1 and 2 only) |
+| PrecodeMachineDescriptor | ReadWidthOfPrecodeType | See `ReadPrecodeType` (Version 1 and 2 only) |
| PrecodeMachineDescriptor | StubCodePageSize | Size of a precode code page (in bytes) |
| PrecodeMachineDescriptor | CodePointerToInstrPointerMask | mask to apply to code pointers to get an address (see arm32 note)
| PrecodeMachineDescriptor | StubPrecodeType | precode sort byte for stub precodes |
| PrecodeMachineDescriptor | HasPInvokeImportPrecode | 1 if platform supports PInvoke precode stubs |
-| PrecodeMachineDescriptor | PInvokeImportPrecodeType| precode sort byte for PInvoke precode stubs, if supported |
+| PrecodeMachineDescriptor | PInvokeImportPrecodeType | precode sort byte for PInvoke precode stubs, if supported |
| PrecodeMachineDescriptor | HasFixupPrecode | 1 if platform supports fixup precode stubs |
-| PrecodeMachineDescriptor | FixupPrecodeType| precode sort byte for fixup precode stubs, if supported |
+| PrecodeMachineDescriptor | FixupPrecodeType | precode sort byte for fixup precode stubs, if supported |
| PrecodeMachineDescriptor | ThisPointerRetBufPrecodeType | precode sort byte for this pointer ret buf precodes |
+| PrecodeMachineDescriptor | FixupStubPrecodeSize | Byte size of `FixupBytes` and `FixupIgnoredBytes` (Version 3 only) |
+| PrecodeMachineDescriptor | FixupBytes | Assembly code of a FixupStub (Version 3 only) |
+| PrecodeMachineDescriptor | FixupIgnoredBytes | Bytes to ignore of when comparing `FixupBytes` to an actual block of memory in the target process. (Version 3 only) |
+| PrecodeMachineDescriptor | StubPrecodeSize | Byte size of `StubBytes` and `StubIgnoredBytes` (Version 3 only) |
+| PrecodeMachineDescriptor | StubBytes | Assembly code of a StubPrecode (Version 3 only) |
+| PrecodeMachineDescriptor | StubIgnoredBytes | Bytes to ignore of when comparing `StubBytes` to an actual block of memory in the target process. (Version 3 only) |
+| PrecodeMachineDescriptor | FixupCodeOffset | Offset of second entrypoint into a `FixupStub` (Present in data for Version 3 and above only.) |
+| PrecodeMachineDescriptor | InterpreterPrecodeType | precode sort byte for the entrypoint into the interpreter (Version 3 only) |
+| PrecodeMachineDescriptor | UMEntryPrecodeType | precode sort byte for the entrypoint into the UMEntry thunk (Version 3 only) |
+| PrecodeMachineDescriptor | DynamicHelperPrecodeType | precode sort byte for the entrypoint into a dynamic helper (Version 3 only) |
| StubPrecodeData | MethodDesc | pointer to the MethodDesc associated with this stub precode (Version 1 only) |
| StubPrecodeData | SecretParam | pointer to the MethodDesc associated with this stub precode or a second stub data pointer for other types (Version 2 only) |
| StubPrecodeData | Type | precise sort of stub precode |
@@ -44,12 +54,75 @@ Contracts used:
| --- |
| `PlatformMetadata` |
-### Determining the precode type
+### Determining the precode type (Version 3)
+``` csharp
+ private bool ReadBytesAndCompare(TargetPointer instrAddress, byte[] expectedBytePattern, byte[] bytesToIgnore)
+ {
+ byte[] localCopy = new byte[expectedBytePattern.Length];
+ for (int i = 0; i < expectedBytePattern.Length; i++)
+ {
+ if (bytesToIgnore[i] == 0)
+ {
+ byte targetBytePattern = _target.Read(instrAddress + i);
+ if (expectedBytePattern[i] != targetBytePattern)
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+ private KnownPrecodeType? TryGetKnownPrecodeType(TargetPointer instrAddress)
+ {
+ KnownPrecodeType? basicPrecodeType = default;
+ if (ReadBytesAndCompare(instrAddress, MachineDescriptor.StubBytes, MachineDescriptor.StubIgnoredBytes))
+ {
+ // get the actual type from the StubPrecodeData
+ Data.StubPrecodeData stubPrecodeData = GetStubPrecodeData(instrAddress);
+ byte exactPrecodeType = stubPrecodeData.Type;
+ if (exactPrecodeType == 0)
+ return null;
+
+ if (exactPrecodeType == MachineDescriptor.StubPrecodeType)
+ {
+ return KnownPrecodeType.Stub;
+ }
+ else if (MachineDescriptor.PInvokeImportPrecodeType is byte compareByte1 && compareByte1 == exactPrecodeType)
+ {
+ return KnownPrecodeType.PInvokeImport;
+ }
+ else if (MachineDescriptor.ThisPointerRetBufPrecodeType is byte compareByte2 && compareByte2 == exactPrecodeType)
+ {
+ return KnownPrecodeType.ThisPtrRetBuf;
+ }
+ else if (MachineDescriptor.UMEntryPrecodeType is byte compareByte3 && compareByte3 == exactPrecodeType)
+ {
+ return KnownPrecodeType.UMEntry;
+ }
+ else if (MachineDescriptor.InterpreterPrecodeType is byte compareByte4 && compareByte4 == exactPrecodeType)
+ {
+ return KnownPrecodeType.Interpreter;
+ }
+ else if (MachineDescriptor.DynamicHelperPrecodeType is byte compareByte5 && compareByte5 == exactPrecodeType)
+ {
+ return KnownPrecodeType.DynamicHelper;
+ }
+ }
+ else if (ReadBytesAndCompare(instrAddress, MachineDescriptor.FixupBytes, MachineDescriptor.FixupIgnoredBytes))
+ {
+ return KnownPrecodeType.Fixup;
+ }
+ return null;
+ }
+```
+
+### Determining the precode type (Version 1 and 2)
An initial approximation of the precode type relies on a particular pattern at a known offset from the precode entrypoint.
The precode type is expected to be encoded as an immediate. On some platforms the value is spread over multiple instruction bytes and may need to be right-shifted.
-```
+```csharp
private byte ReadPrecodeType(TargetPointer instrPointer)
{
if (MachineDescriptor.ReadWidthOfPrecodeType == 1)
@@ -121,9 +194,12 @@ After the initial precode type is determined, for stub precodes a refined precod
internal enum KnownPrecodeType
{
Stub = 1,
- PInvokeImport, // also known as NDirectImport in the runtime
+ PInvokeImport,
Fixup,
ThisPtrRetBuf,
+ UMEntry,
+ DynamicHelper,
+ Interpreter
}
internal abstract class ValidPrecode
diff --git a/docs/design/datacontracts/RuntimeTypeSystem.md b/docs/design/datacontracts/RuntimeTypeSystem.md
index f0bfe7b66eb571..86fe79087fb690 100644
--- a/docs/design/datacontracts/RuntimeTypeSystem.md
+++ b/docs/design/datacontracts/RuntimeTypeSystem.md
@@ -53,15 +53,25 @@ partial interface IRuntimeTypeSystem : IContract
// True if the MethodTable represents a type that contains managed references
public virtual bool ContainsGCPointers(TypeHandle typeHandle);
public virtual bool IsDynamicStatics(TypeHandle typeHandle);
- public virtual ushort GetNumMethods(TypeHandle typeHandle);
public virtual ushort GetNumInterfaces(TypeHandle typeHandle);
// Returns an ECMA-335 TypeDef table token for this type, or for its generic type definition if it is a generic instantiation
public virtual uint GetTypeDefToken(TypeHandle typeHandle);
+ public virtual ushort GetNumMethods(TypeHandle typeHandle);
// Returns the ECMA 335 TypeDef table Flags value (a bitmask of TypeAttributes) for this type,
// or for its generic type definition if it is a generic instantiation
public virtual uint GetTypeDefTypeAttributes(TypeHandle typeHandle);
+ public ushort GetNumInstanceFields(TypeHandle typeHandle);
+ public ushort GetNumStaticFields(TypeHandle typeHandle);
+ public ushort GetNumThreadStaticFields(TypeHandle typeHandle);
+ public TargetPointer GetGCThreadStaticsBasePointer(TypeHandle typeHandle, TargetPointer threadPtr);
+ public TargetPointer GetNonGCThreadStaticsBasePointer(TypeHandle typeHandle, TargetPointer threadPtr);
+ public TargetPointer GetFieldDescList(TypeHandle typeHandle);
+ public TargetPointer GetGCStaticsBasePointer(TypeHandle typeHandle);
+ public TargetPointer GetNonGCStaticsBasePointer(TypeHandle typeHandle);
public virtual ReadOnlySpan GetInstantiation(TypeHandle typeHandle);
+ public bool IsClassInited(TypeHandle typeHandle);
+ public bool IsInitError(TypeHandle typeHandle);
public virtual bool IsGenericTypeDefinition(TypeHandle typeHandle);
public virtual bool HasTypeParam(TypeHandle typeHandle);
@@ -331,6 +341,7 @@ The contract depends on the following globals
| Global name | Meaning |
| --- | --- |
| `FreeObjectMethodTablePointer` | A pointer to the address of a `MethodTable` used by the GC to indicate reclaimed memory
+| `StaticsPointerMask` | For masking out a bit of DynamicStaticsInfo pointer fields
The contract additionally depends on these data descriptors
@@ -345,12 +356,23 @@ The contract additionally depends on these data descriptors
| `MethodTable` | `NumInterfaces` | Number of interfaces of `MethodTable` |
| `MethodTable` | `NumVirtuals` | Number of virtual methods in `MethodTable` |
| `MethodTable` | `PerInstInfo` | Either the array element type, or pointer to generic information for `MethodTable` |
+| `MethodTableAuxiliaryData` | `Flags` | Flags of `MethodTableAuxiliaryData` |
+| `MethodTable` | `AuxiliaryData` | Pointer to the AuxiliaryData of a method table |
+| `DynamicStaticsInfo` | `NonGCStatics` | Pointer to non-GC statics |
+| `DynamicStaticsInfo` | `GCStatics` | Pointer to the GC statics |
+| `DynamicStaticsInfo` | `Size` | Size of the data |
+| `ThreadStaticsInfo` | `GCTlsIndex` | Pointer to GC thread local storage index |
+| `ThreadStaticsInfo` | `NonGCTlsIndex` | Pointer to non-GC thread local storage index |
| `EEClass` | `InternalCorElementType` | An InternalCorElementType uses the enum values of a CorElementType to indicate some of the information about the type of the type which uses the EEClass In particular, all reference types are CorElementType.Class, Enums are the element type of their underlying type and ValueTypes which can exactly be represented as an element type are represented as such, all other values types are represented as CorElementType.ValueType. |
| `EEClass` | `MethodTable` | Pointer to the canonical MethodTable of this type |
| `EEClass` | `MethodDescChunk` | Pointer to the first MethodDescChunk of the EEClass |
| `EEClass` | `NumMethods` | Count of methods attached to the EEClass |
| `EEClass` | `NumNonVirtualSlots` | Count of non-virtual slots for the EEClass |
| `EEClass` | `CorTypeAttr` | Various flags |
+| `EEClass` | `NumInstanceFields` | Count of instance fields of the EEClass |
+| `EEClass` | `NumStaticFields` | Count of static fields of the EEClass |
+| `EEClass` | `NumThreadStaticFields` | Count of threadstatic fields of the EEClass |
+| `EEClass` | `FieldDescList` | A list of fields in the type |
| `ArrayClass` | `Rank` | Rank of the associated array MethodTable |
| `TypeDesc` | `TypeAndFlags` | The lower 8 bits are the CorElementType of the `TypeDesc`, the upper 24 bits are reserved for flags |
| `ParamTypeDesc` | `TypeArg` | Associated type argument |
@@ -362,6 +384,11 @@ The contract additionally depends on these data descriptors
| `GenericsDictInfo` | `NumDicts` | Number of instantiation dictionaries, including inherited ones, in this `GenericsDictInfo` |
| `GenericsDictInfo` | `NumTypeArgs` | Number of type arguments in the type or method instantiation described by this `GenericsDictInfo` |
+Contracts used:
+| Contract Name |
+| --- |
+| `Thread` |
+
```csharp
private readonly Dictionary _methodTables;
@@ -377,11 +404,35 @@ The contract additionally depends on these data descriptors
return TypeHandle { Address = typeHandlePointer }
}
+ public TargetPointer GetModule(TypeHandle TypeHandle)
+ {
+ if (typeHandle.IsMethodTable())
+ {
+ return _methodTables[TypeHandle.Address].Module;
+ }
+ else if (typeHandle.IsTypeDesc())
+ {
+ if (HasTypeParam(typeHandle))
+ {
+ return GetModule(GetTypeParam(typeHandle));
+ }
+ else if (IsGenericVariable(typeHandle, out TargetPointer genericParamModule, out _))
+ {
+ return genericParamModule;
+ }
+ }
+ return TargetPointer.Null;
+ }
+
internal static EEClassOrCanonMTBits GetEEClassOrCanonMTBits(TargetPointer eeClassOrCanonMTPtr)
{
return (EEClassOrCanonMTBits)(eeClassOrCanonMTPtr & (ulong)EEClassOrCanonMTBits.Mask);
}
+ public TargetPointer GetCanonicalMethodTable(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? TargetPointer.Null : GetClassData(TypeHandle).MethodTable;
+
+ public TargetPointer GetParentMethodTable(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? TargetPointer.Null : _methodTables[TypeHandle.Address].ParentMethodTable;
+
public uint GetBaseSize(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? (uint)0 : _methodTables[TypeHandle.Address].Flags.BaseSize;
public uint GetComponentSize(TypeHandle TypeHandle) =>!typeHandle.IsMethodTable() ? (uint)0 : GetComponentSize(_methodTables[TypeHandle.Address]);
@@ -400,36 +451,16 @@ The contract additionally depends on these data descriptors
... // read Data.EEClass data from eeClassPtr
}
-
- public TargetPointer GetCanonicalMethodTable(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? TargetPointer.Null : GetClassData(TypeHandle).MethodTable;
-
- public TargetPointer GetModule(TypeHandle TypeHandle)
- {
- if (typeHandle.IsMethodTable())
- {
- return _methodTables[TypeHandle.Address].Module;
- }
- else if (typeHandle.IsTypeDesc())
- {
- if (HasTypeParam(typeHandle))
- {
- return GetModule(GetTypeParam(typeHandle));
- }
- else if (IsGenericVariable(typeHandle, out TargetPointer genericParamModule, out _))
- {
- return genericParamModule;
- }
- }
- return TargetPointer.Null;
- }
-
- public TargetPointer GetParentMethodTable(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? TargetPointer.Null : _methodTables[TypeHandle.Address].ParentMethodTable;
-
public bool IsFreeObjectMethodTable(TypeHandle TypeHandle) => FreeObjectMethodTablePointer == TypeHandle.Address;
public bool IsString(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.IsString;
+
public bool ContainsGCPointers(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.ContainsGCPointers;
+ public bool IsDynamicStatics(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.IsDynamicStatics;
+
+ public ushort GetNumInterfaces(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? 0 : _methodTables[TypeHandle.Address].NumInterfaces;
+
public uint GetTypeDefToken(TypeHandle TypeHandle)
{
if (!typeHandle.IsMethodTable())
@@ -441,11 +472,71 @@ The contract additionally depends on these data descriptors
public ushort GetNumMethods(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? 0 : GetClassData(TypeHandle).NumMethods;
- public ushort GetNumInterfaces(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? 0 : _methodTables[TypeHandle.Address].NumInterfaces;
-
public uint GetTypeDefTypeAttributes(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? 0 : GetClassData(TypeHandle).CorTypeAttr;
- public bool IsDynamicStatics(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.IsDynamicStatics;
+ public ushort GetNumInstanceFields(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? (ushort)0 : GetClassData(typeHandle).NumInstanceFields;
+
+ public ushort GetNumStaticFields(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? (ushort)0 : GetClassData(typeHandle).NumStaticFields;
+
+ public ushort GetNumThreadStaticFields(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? (ushort)0 : GetClassData(typeHandle).NumThreadStaticFields;
+
+ public TargetPointer GetFieldDescList(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? TargetPointer.Null : GetClassData(typeHandle).FieldDescList;
+
+ public TargetPointer GetGCStaticsBasePointer(TypeHandle typeHandle)
+ {
+ if (!typeHandle.IsMethodTable())
+ return TargetPointer.Null;
+
+ MethodTable methodTable = _methodTables[typeHandle.Address];
+ if (!methodTable.Flags.IsDynamicStatics)
+ return TargetPointer.Null;
+ TargetPointer dynamicStaticsInfoSize = target.GetTypeInfo(DataType.DynamicStaticsInfo).Size!.Value;
+ TargetPointer mask = target.ReadGlobalPointer("StaticsPointerMask");
+
+ TargetPointer dynamicStaticsInfo = methodTable.AuxiliaryData - dynamicStaticsInfoSize;
+ return (target.ReadPointer(dynamicStaticsInfo + /* DynamicStaticsInfo::GCStatics offset */) & (ulong)mask);
+ }
+
+ public TargetPointer GetNonGCStaticsBasePointer(TypeHandle typeHandle)
+ {
+ if (!typeHandle.IsMethodTable())
+ return TargetPointer.Null;
+
+ MethodTable methodTable = _methodTables[typeHandle.Address];
+ if (!methodTable.Flags.IsDynamicStatics)
+ return TargetPointer.Null;
+ TargetPointer dynamicStaticsInfoSize = target.GetTypeInfo(DataType.DynamicStaticsInfo).Size!.Value;
+ TargetPointer mask = target.ReadGlobalPointer("StaticsPointerMask");
+
+ TargetPointer dynamicStaticsInfo = methodTable.AuxiliaryData - dynamicStaticsInfoSize;
+ return (target.ReadPointer(dynamicStaticsInfo + /* DynamicStaticsInfo::NonGCStatics offset */) & (ulong)mask);
+ }
+
+ public TargetPointer GetGCThreadStaticsBasePointer(TypeHandle typeHandle, TargetPointer threadPtr)
+ {
+ if (!typeHandle.IsMethodTable())
+ return TargetPointer.Null;
+ MethodTable_1 methodTable = _methodTables[typeHandle.Address];
+ TargetPointer threadStaticsInfoSize = target.GetTypeInfo(DataType.ThreadStaticsInfo).Size;
+ TargetPointer threadStaticsInfoAddr = methodTable.AuxiliaryData - threadStaticsInfoSize;
+
+ TargetPointer tlsIndexAddr = threadStaticsInfoAddr + /* ThreadStaticsInfo::GCTlsIndex offset */;
+ Contracts.IThread threadContract = target.Contracts.Thread;
+ return threadContract.GetThreadLocalStaticBase(threadPtr, tlsIndexAddr);
+ }
+
+ public TargetPointer GetNonGCThreadStaticsBasePointer(TypeHandle typeHandle, TargetPointer threadPtr)
+ {
+ if (!typeHandle.IsMethodTable())
+ return TargetPointer.Null;
+ MethodTable_1 methodTable = _methodTables[typeHandle.Address];
+ TargetPointer threadStaticsInfoSize = target.GetTypeInfo(DataType.ThreadStaticsInfo).Size;
+ TargetPointer threadStaticsInfoAddr = methodTable.AuxiliaryData - threadStaticsInfoSize;
+
+ TargetPointer tlsIndexAddr = threadStaticsInfoAddr + /* ThreadStaticsInfo::NonGCTlsIndex offset */;
+ Contracts.IThread threadContract = target.Contracts.Thread;
+ return threadContract.GetThreadLocalStaticBase(threadPtr, tlsIndexAddr);
+ }
public ReadOnlySpan GetInstantiation(TypeHandle TypeHandle)
{
@@ -468,6 +559,26 @@ The contract additionally depends on these data descriptors
return instantiation;
}
+ public bool IsClassInited(TypeHandle typeHandle)
+ {
+ if (!typeHandle.IsMethodTable())
+ return false;
+ TargetPointer auxiliaryDataPtr = target.ReadPointer(typeHandle.Address + /* MethodTable.AuxiliaryData offset */);
+ TargetPointer flagsPtr = target.ReadPointer(auxiliaryDataPtr + /* MethodTableAuxiliaryData::Flags offset */);
+ uint flags = target.Read(flagsPtr);
+ return (flags & (uint)MethodTableAuxiliaryFlags.Initialized) != 0;
+ }
+
+ public bool IsInitError(TypeHandle typeHandle)
+ {
+ if (!typeHandle.IsMethodTable())
+ return false;
+ TargetPointer auxiliaryDataPtr = target.ReadPointer(typeHandle.Address + /* MethodTable.AuxiliaryData offset */);
+ TargetPointer flagsPtr = target.ReadPointer(auxiliaryDataPtr + /* MethodTableAuxiliaryData::Flags offset */);
+ uint flags = target.Read(flagsPtr);
+ return (flags & (uint)MethodTableAuxiliaryFlags.IsInitError) != 0;
+ }
+
public bool IsDynamicStatics(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.IsDynamicStatics;
public bool HasTypeParam(TypeHandle typeHandle)
@@ -675,7 +786,6 @@ The contract depends on the following other contracts
| ReJIT |
| ExecutionManager |
| PrecodeStubs |
-| ECall |
And the following enumeration definitions
@@ -740,6 +850,12 @@ And the following enumeration definitions
TemporaryEntryPointAssigned = 0x04,
}
+ internal enum MethodTableAuxiliaryFlags : uint
+ {
+ Initialized = 0x0001,
+ IsInitError = 0x0100,
+ }
+
```
Internal to the contract in order to answer queries about method descriptors,
@@ -868,7 +984,7 @@ And the various apis are implemented with the following algorithms
ushort FlagsAndTokenRange = // Read FlagsAndTokenRange field from MethodDescChunk contract using address methodDescChunk
- int tokenRemainderBitCount = _target.ReadGlobal(Constants.Globals.MethodDescTokenRemainderBitCount);
+ int tokenRemainderBitCount = _target.ReadGlobal("MethodDescTokenRemainderBitCount");
int tokenRangeBitCount = 24 - tokenRemainderBitCount;
uint allRidBitsSet = 0xFFFFFF;
uint tokenRemainderMask = allRidBitsSet >> tokenRangeBitCount;
@@ -1030,7 +1146,7 @@ Determining if a method is in a collectible module:
{
MethodDesc md = _methodDescs[methodDesc.Address];
TargetPointer loaderModuleAddr = GetLoaderModule(md);
- ModuleHandle mod = _target.Contracts.Loader.GetModuleHandle(loaderModuleAddr);
+ ModuleHandle mod = _target.Contracts.Loader.GetModuleHandleFromModulePtr(loaderModuleAddr);
return _target.Contracts.Loader.IsCollectible(mod);
}
@@ -1093,7 +1209,7 @@ Checking if a method has a native code slot and getting its address
{
MethodClassification.IL => /*size of MethodDesc*/,
MethodClassification.FCall => /* size of FCallMethodDesc */
- MethodClassification.PInvoke => /* size of NDirectMethodDesc */
+ MethodClassification.PInvoke => /* size of PInvokeMethodDesc */
MethodClassification.EEImpl => /* size of EEImplMethodDesc */
MethodClassification.Array => /* size of ArrayMethodDesc */
MethodClassification.Instantiated => /* size of InstantiatedMethodDesc */
@@ -1230,15 +1346,6 @@ Getting a MethodDesc for a certain slot in a MethodTable
return methodDescPtr;
}
- // FCall path, look up address in the FCall table using the ECall contract
- {
- TargetPointer methodDescPtr = _target.Contracts.ECall.MapTargetBackToMethodDesc(pCode);
- if (methodDescPtr != TargetPointer.Null)
- {
- return methodDescPtr;
- }
- }
-
// Stub path, read address as a Precode and get the MethodDesc from it
{
TargetPointer methodDescPtr = _target.Contracts.PrecodeStubs.GetMethodDescFromStubAddress(pCode);
@@ -1258,16 +1365,20 @@ Getting a MethodDesc for a certain slot in a MethodTable
if (pCode == TargetCodePointer.Null)
{
- // if pCode is null, we iterate through the method descs in the MT.
- foreach (MethodDescHandle mdh in GetIntroducedMethods(typeHandle))
+ // if pCode is null, we iterate through the method descs in the MT
+ while (true) // arbitrary limit to avoid infinite loop
{
- MethodDesc md = _methodDescs[mdh.Address];
-
- // if a MethodDesc matches the slot, return that MethodDesc
- if (md.Slot == slot)
+ foreach (MethodDescHandle mdh in GetIntroducedMethods(canonMT))
{
- return mdh.Address;
+ MethodDesc md = _methodDescs[mdh.Address];
+
+ // if a MethodDesc matches the slot, return that MethodDesc
+ if (md.Slot == slot)
+ {
+ return mdh.Address;
+ }
}
+ canonMT = GetTypeHandle(GetCanonicalMethodTable(GetTypeHandle(GetParentMethodTable(canonMT))));
}
}
diff --git a/docs/design/datacontracts/StressLog.md b/docs/design/datacontracts/StressLog.md
index abb7824a837f0c..3b90a216cfdf50 100644
--- a/docs/design/datacontracts/StressLog.md
+++ b/docs/design/datacontracts/StressLog.md
@@ -53,6 +53,7 @@ Data descriptors used:
| StressLog | TickFrequency | Number of ticks per second for stresslog timestamps |
| StressLog | StartTimestamp | Timestamp when the stress log was started |
| StressLog | ModuleOffset | Offset of the module in the stress log |
+| StressLog | Modules | Offset of the stress log's module table (if StressLogHasModuleTable is `1`) |
| StressLog | Logs | Pointer to the thread-specific logs |
| StressLogModuleDesc | BaseAddress | Base address of the module |
| StressLogModuleDesc | Size | Size of the module |
@@ -80,7 +81,6 @@ Global variables used:
| StressLogChunkSize | uint | Size of a stress log chunk |
| StressLogMaxMessageSize | ulong | Maximum size of a stress log message |
| StressLogHasModuleTable | byte | Whether the stress log module table is present |
-| StressLogModuleTable | pointer | Pointer to the stress log's module table (if StressLogHasModuleTable is `1`) |
```csharp
bool HasStressLog()
@@ -95,7 +95,7 @@ StressLogData GetStressLogData()
return default;
}
- StressLog stressLog = new StressLog(Target, Target.ReadGlobalPointer(Constants.Globals.StressLog));
+ StressLog stressLog = new StressLog(Target, Target.ReadGlobalPointer("StressLog"));
return new StressLogData(
stressLog.LoggedFacilities,
stressLog.Level,
@@ -210,18 +210,27 @@ bool IsPointerInStressLog(StressLogData stressLog, TargetPointer pointer)
// This method is a helper for the various specific versions.
protected TargetPointer GetFormatPointer(ulong formatOffset)
{
- if (Target.ReadGlobal(Constants.Globals.StressLogHasModuleTable) == 0)
+ if (Target.ReadGlobal("StressLogHasModuleTable") == 0)
{
- StressLog stressLog = new(Target, target.ReadGlobalPointer(Constants.Globals.StressLog));
+ StressLog stressLog = new(Target, target.ReadGlobalPointer("StressLog"));
return new TargetPointer(stressLog.ModuleOffset + formatOffset);
}
- TargetPointer moduleTable = target.ReadGlobalPointer(Constants.Globals.StressLogModuleTable);
+ TargetPointer? moduleTable;
+ if (!target.TryReadGlobalPointer(Constants.Globals.StressLogModuleTable, out moduleTable))
+ {
+ if (!target.TryReadGlobalPointer(Constants.Globals.StressLog, out TargetPointer? pStressLog))
+ {
+ throw new InvalidOperationException("StressLogModuleTable is not set and StressLog is not available, but StressLogHasModuleTable is set to 1.");
+ }
+ Data.StressLog stressLog = target.ProcessedData.GetOrAdd(pStressLog.Value);
+ moduleTable = stressLog.Modules ?? throw new InvalidOperationException("StressLogModuleTable is not set and StressLog does not contain a ModuleTable offset, but StressLogHasModuleTable is set to 1.");
+ }
uint moduleEntrySize = target.GetTypeInfo(DataType.StressLogModuleDesc).Size!.Value;
- uint maxModules = target.ReadGlobal(Constants.Globals.StressLogMaxModules);
+ uint maxModules = target.ReadGlobal("StressLogMaxModules");
for (uint i = 0; i < maxModules; ++i)
{
- StressLogModuleDesc module = new(Target, moduleTable + i * moduleEntrySize);
+ StressLogModuleDesc module = new(Target, moduleTable.Value + i * moduleEntrySize);
ulong relativeOffset = formatOffset - cumulativeOffset;
if (relativeOffset < module.Size.Value)
{
@@ -313,7 +322,7 @@ The format offset refers to the cummulative offset into a module referred to in
```csharp
StressMsgData GetStressMsgData(StressMsg msg)
{
- StressLog stressLog = new(Target, target.ReadGlobalPointer(Constants.Globals.StressLog));
+ StressLog stressLog = new(Target, target.ReadGlobalPointer("StressLog"));
uint pointerSize = Target.GetTypeInfo(DataType.pointer).Size!.Value;
ulong payload1 = target.Read(msg.Header);
diff --git a/docs/design/datacontracts/Thread.md b/docs/design/datacontracts/Thread.md
index efdd7d0bbc653a..dcd0e39e611d13 100644
--- a/docs/design/datacontracts/Thread.md
+++ b/docs/design/datacontracts/Thread.md
@@ -46,29 +46,73 @@ record struct ThreadData (
ThreadStoreData GetThreadStoreData();
ThreadStoreCounts GetThreadCounts();
ThreadData GetThreadData(TargetPointer threadPointer);
-TargetPointer GetManagedThreadObject(TargetPointer threadPointer);
+TargetPointer IdToThread(uint id);
+TargetPointer GetThreadLocalStaticBase(TargetPointer threadPointer, int indexOffset, int indexType);
```
## Version 1
-This contract depends on the following descriptors:
-
-| Data descriptor name |
-| --- |
-| `GCAllocContext` |
-| `RuntimeThreadLocals` |
-| `Thread` |
-| `ThreadStore` |
-
-| Global name |
-| --- |
-| `AppDomain` |
-| `ThreadStore` |
-| `FeatureEHFunclets` |
-| `FinalizerThread` |
-| `GCThread` |
-
+The contract depends on the following globals
+
+| Global name | Type | Meaning |
+| --- | --- |
+| `AppDomain` | TargetPointer | A pointer to the address of the one AppDomain
+| `ThreadStore` | TargetPointer | A pointer to the address of the ThreadStore
+| `FeatureEHFunclets` | TargetPointer | 1 if EH funclets are enabled, 0 otherwise
+| `FinalizerThread` | TargetPointer | A pointer to the finalizer thread
+| `GCThread` | TargetPointer | A pointer to the GC thread
+| `ThinLockThreadIdDispenser` | TargetPointer | Dispenser of thinlock IDs for locking objects
+| `NumberOfTlsOffsetsNotUsedInNoncollectibleArray` | byte | Number of unused slots in noncollectible TLS array
+| `PtrArrayOffsetToDataArray` | TargetPointer | Offset from PtrArray class address to start of enclosed data array
+
+The contract additionally depends on these data descriptors
+
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| `ExceptionInfo` | `PreviousNestedInfo` | Pointer to previous nested exception info |
+| `GCAllocContext` | `Pointer` | GC allocation pointer |
+| `GCAllocContext` | `Limit` | Allocation limit pointer |
+| `IdDispenser` | `HighestId` | Highest possible small thread ID |
+| `IdDispenser` | `IdToThread` | Array mapping small thread IDs to thread pointers |
+| `InflightTLSData` | `Next` | Pointer to next in-flight TLS data entry |
+| `InflightTLSData` | `TlsIndex` | TLS index for the in-flight static field |
+| `InflightTLSData` | `TLSData` | Object handle to the TLS data for the static field |
+| `ObjectHandle` | `Object` | Pointer to the managed object |
+| `RuntimeThreadLocals` | `AllocContext` | GC allocation context for the thread |
+| `TLSIndex` | `IndexOffset` | Offset index for thread local storage |
+| `TLSIndex` | `IndexType` | Type of thread local storage index |
+| `TLSIndex` | `IsAllocated` | Whether TLS storage has been allocated |
+| `TLSIndex` | `TLSIndexRawIndex` | Raw index value containing type and offset |
+| `Thread` | `Id` | Thread identifier |
+| `Thread` | `OSId` | Operating system thread identifier |
+| `Thread` | `State` | Thread state flags |
+| `Thread` | `PreemptiveGCDisabled` | Flag indicating if preemptive GC is disabled |
+| `Thread` | `Frame` | Pointer to current frame |
+| `Thread` | `TEB` | Thread Environment Block pointer |
+| `Thread` | `LastThrownObject` | Handle to last thrown exception object |
+| `Thread` | `LinkNext` | Pointer to get next thread |
+| `Thread` | `ExceptionTracker` | Pointer to exception tracking information |
+| `Thread` | `RuntimeThreadLocals` | Pointer to some thread-local storage |
+| `Thread` | `ThreadLocalDataPtr` | Pointer to thread local data structure |
+| `ThreadLocalData` | `NonCollectibleTlsData` | Count of non-collectible TLS data entries |
+| `ThreadLocalData` | `NonCollectibleTlsArrayData` | Pointer to non-collectible TLS array data |
+| `ThreadLocalData` | `CollectibleTlsData` | Count of collectible TLS data entries |
+| `ThreadLocalData` | `CollectibleTlsArrayData` | Pointer to collectible TLS array data |
+| `ThreadLocalData` | `InFlightData` | Pointer to in-flight TLS data for fields being initialized |
+| `ThreadStore` | `ThreadCount` | Number of threads |
+| `ThreadStore` | `FirstThreadLink` | Pointer to first thread in the linked list |
+| `ThreadStore` | `UnstartedCount` | Number of unstarted threads |
+| `ThreadStore` | `BackgroundCount` | Number of background threads |
+| `ThreadStore` | `PendingCount` | Number of pending threads |
+| `ThreadStore` | `DeadCount` | Number of dead threads |
``` csharp
+enum TLSIndexType
+{
+ NonCollectible = 0,
+ Collectible = 1,
+ DirectOnThreadLocalData = 2,
+};
+
ThreadStoreData GetThreadStoreData()
{
TargetPointer threadStore = target.ReadGlobalPointer("ThreadStore");
@@ -94,11 +138,11 @@ DacThreadStoreCounts GetThreadCounts()
ThreadData GetThreadData(TargetPointer address)
{
- var runtimeThread = new Thread(Target, threadPointer);
+ var runtimeThread = new Thread(target, threadPointer);
// Exception tracker is a pointer when EH funclets are enabled
- TargetPointer exceptionTrackerAddr = _target.ReadGlobal("FeatureEHFunclets") != 0
- ? _target.ReadPointer(address + /* Thread::ExceptionTracker offset */)
+ TargetPointer exceptionTrackerAddr = target.ReadGlobal("FeatureEHFunclets") != 0
+ ? target.ReadPointer(address + /* Thread::ExceptionTracker offset */)
: address + /* Thread::ExceptionTracker offset */;
TargetPointer firstNestedException = exceptionTrackerAddr != TargetPointer.Null
? target.ReadPointer(exceptionTrackerAddr + /* ExceptionInfo::PreviousNestedInfo offset*/)
@@ -129,9 +173,71 @@ ThreadData GetThreadData(TargetPointer address)
);
}
-TargetPointer GetManagedThreadObject(TargetPointer threadPointer)
+TargetPointer IThread.IdToThread(uint id)
+{
+ TargetPointer idDispenserPointer = target.ReadGlobalPointer(Constants.Globals.ThinlockThreadIdDispenser);
+ TargetPointer idDispenser = target.ReadPointer(idDispenserPointer);
+ uint HighestId = target.ReadPointer(idDispenser + /* IdDispenser::HighestId offset */);
+ TargetPointer threadPtr = TargetPointer.Null;
+ if (id < HighestId)
+ threadPtr = target.ReadPointer(idDispenser + /* IdDispenser::IdToThread offset + (index into IdToThread array * size of array elements (== size of target pointer)) */);
+ return threadPtr;
+}
+
+TargetPointer IThread.GetThreadLocalStaticBase(TargetPointer threadPointer, TargetPointer tlsIndexPtr)
{
- var runtimeThread = new Thread(Target, threadPointer);
- return Contracts.GCHandle.GetObject(new DacGCHandle(runtimeThread.m_ExposedObject));
+ // Get the thread's TLS base address
+ TargetPointer threadLocalDataPtr = target.ReadPointer(threadPointer + /* Thread::ThreadLocalDataPtr offset */);
+ if (threadLocalDataPtr == TargetPointer.Null)
+ return TargetPointer.Null;
+
+ Data.TLSIndex tlsIndex = new Data.TLSIndex(tlsIndexPtr);
+ if (!tlsIndex.IsAllocated)
+ return TargetPointer.Null;
+
+ TargetPointer threadLocalStaticBase = default;
+ int indexType = tlsIndex.IndexType;
+ int indexOffset = tlsIndex.IndexOffset;
+ switch ((TLSIndexType)indexType)
+ {
+ case TLSIndexType.NonCollectible:
+ int nonCollectibleCount = target.ReadPointer(threadLocalDataPtr + /* ThreadLocalData::NonCollectibleTlsDataCount offset */);
+ // bounds check
+ if (nonCollectibleCount > indexOffset)
+ {
+ TargetPointer nonCollectibleArray = target.ReadPointer(threadLocalDataPtr + /* ThreadLocalData::NonCollectibleTlsArrayData offset */);
+ int arrayIndex = indexOffset - target.ReadGlobal("NumberOfTlsOffsetsNotUsedInNoncollectibleArray");
+ TargetPointer arrayStartAddress = nonCollectibleArray + target.ReadGlobalPointer("PtrArrayOffsetToDataArray");
+ threadLocalStaticBase = target.ReadPointer(arrayStartAddress + (ulong)(arrayIndex * target.PointerSize));
+ }
+ break;
+ case TLSIndexType.Collectible:
+ int collectibleCount = target.ReadPointer(threadLocalDataPtr + /* ThreadLocalData::CollectibleTlsDataCount offset */);
+ if (collectibleCount > indexOffset)
+ {
+ TargetPointer collectibleArray = target.ReadPointer(threadLocalDataPtr + /* ThreadLocalData::CollectibleTlsArrayData offset */);
+ threadLocalStaticBase = target.ReadPointer(collectibleArray + (ulong)(indexOffset * target.PointerSize));
+ }
+ break;
+ case TLSIndexType.DirectOnThreadLocalData:
+ threadLocalStaticBase = threadLocalDataPtr;
+ break;
+ }
+ if (threadLocalStaticBase == TargetPointer.Null)
+ {
+ TargetPointer inFlightData = target.ReadPointer(threadLocalDataPtr + /* ThreadLocalData::inFlightData offset */);
+ while (inFlightData != TargetPointer.Null)
+ {
+ TargetPointer tlsIndexInFlightPtr = target.ReadPointer(inFlightData + /* InflightTLSData::TlsIndex offset */);
+ Data.TLSIndex tlsIndexInFlight = new Data.TLSIndex(tlsIndexInFlightPtr);
+ if (tlsIndexInFlight.TLSIndexRawIndex == tlsIndex.TLSIndexRawIndex)
+ {
+ threadLocalStaticBase = target.ReadPointer(tlsIndexInFlightPtr + /* InflightTLSData::TLSData offset */);
+ break;
+ }
+ inFlightData = target.ReadPointer(inFlightData + /* InflightTLSData::Next offset */);
+ }
+ }
+ return threadLocalStaticBase;
}
```
diff --git a/docs/design/datacontracts/debug_interface_globals.md b/docs/design/datacontracts/debug_interface_globals.md
new file mode 100644
index 00000000000000..c4d1348f138ce0
--- /dev/null
+++ b/docs/design/datacontracts/debug_interface_globals.md
@@ -0,0 +1,22 @@
+# Debug Interface Globals
+
+The following document lists the global variables that are used directly in the debug interface managed code (SOSDacImpl.cs, etc.)
+
+Global variables used
+| Global Name | Type | Purpose |
+| --- | --- | --- |
+| StringMethodTable | TargetPointer | Identify where the string MethodTable exists |
+| ObjectMethodTable | TargetPointer | Identify where the object MethodTable exists |
+| SystemDomain | TargetPointer | Identify where the SystemDomain exists |
+| DirectorySeparator | TargetPointer | Identify where the directory separator exists |
+| FeatureCOMInterop | TargetPointer | Identify where the flag for FeatureCOMInterop exists |
+| StressLog | TargetPointer | Identify where the StressLog exists |
+| AppDomain | TargetPointer | Identify where the AppDomain exists |
+| ObjectArrayMethodTable | TargetPointer | Identify where the ObjectArrayMethodTable exists |
+| ExceptionMethodTable | TargetPointer | Identify where the ExceptionMethodTable exists |
+| FreeObjectMethodTable | TargetPointer | Identify where the FreeObjectMethodTable exists |
+| SOSBreakingChangeVersion | TargetPointer | Identify where the SOSBreakingChangeVersion exists |
+| DacNotificationFlags | TargetPointer | Identify where the DacNotificationFlags exists |
+| MaxClrNotificationArgs | uint32 | Identify the maximum number of CLR notification arguments |
+| ClrNotificationArguments | TargetPointer | Identify where the ClrNotificationArguments exists |
+| DefaultADID | uint | Identify the default AppDomain ID |
diff --git a/docs/design/features/typemap.md b/docs/design/features/typemap.md
index 6501b3b0b33b8a..9e1e7572491625 100644
--- a/docs/design/features/typemap.md
+++ b/docs/design/features/typemap.md
@@ -134,7 +134,7 @@ Given the above types the following would take place.
`TypeMapAttribute` assembly attribute that declared the external type system name, a target
type, and optionally a "trim-target" to determine if the target
type should be included in the map. If the `TypeMapAttribute` constructor that doesn't
-take a trim-target is used, the "target type" will be treated as the "trim-target".
+take a trim-target is used the entry will always be emitted into the type map.
2. Types used in a managed-to-unmanaged interop operation would use `TypeMapAssociationAttribute`
to define a conditional link between the source and proxy type. In other words, if the
@@ -188,14 +188,12 @@ An entry in an External Type Map is included when the "trim target" type is refe
- The argument to the `isinst` IL instruction.
- The argument to the `castclass` IL instruction.
- The argument to the `box` instruction.
+ - If the trimming tool can determine that this box does not escape and could be stack allocated, it can ignore this `box` instruction and any corresponding `unbox` or `unbox.any` instructions.
- The argument to the `mkrefany` instruction.
- The argument to the `refanyval` instruction.
- The argument to the `newarr` instruction.
-- The argument to the `ldobj` instruction.
-- The argument to the `stobj` instruction.
-- The argument to the `.constrained` instruction prefix.
-- The type of a method argument to the `newobj` instruction.
-- The owning type of the method argument to `call`, `callvirt`, `ldftn`, or `ldvirtftn`.
+- The type of a method argument to the `newobj` instruction if it is a class type.
+- The owning type of an instance method argument to `call` or `ldftn`, or the owning type of any method argument to `callvirt` or `ldvirtftn`.
- If the owning type is an interface and the trimming tool can determine that there is only one implementation of the interface, it is free to interpret the method token argument as though it is the method on the only implementing type.
- The generic argument to the `Activator.CreateInstance` method.
- Calls to `Type.GetType` with a constant string representing the type name.
@@ -212,7 +210,6 @@ An entry in the Proxy Type Map is included when the "source type" is referenced
- The generic argument to the `Activator.CreateInstance` method.
- The argument to the `box` instruction.
- The argument to the `newarr` instruction.
-- The argument to the `.constrained` instruction prefix.
- The argument to the `mkrefany` instruction.
- The argument to the `refanyval` instruction.
@@ -221,3 +218,5 @@ If the type is an interface type and the user could possibly see a `RuntimeTypeH
- The argument to the `isinst` IL instruction.
- The argument to the `castclass` IL instruction.
- The owning type of the method argument to `callvirt`, or `ldvirtftn`.
+
+Finally, if the trimming tool determines that it is impossible to retrieve a `System.Type` instance the represents the "source type" at runtime, then the entry may be omitted from the Proxy Type Map as its existence is unobservable.
diff --git a/docs/design/mono/web/linear-ir.md b/docs/design/mono/web/linear-ir.md
index b72e6c28c911c1..4abb62d111ba7a 100644
--- a/docs/design/mono/web/linear-ir.md
+++ b/docs/design/mono/web/linear-ir.md
@@ -41,7 +41,7 @@ Each IR instruction is represented by a MonoInst structure. The fields of the st
- ins-\>opcode contains the opcode of the instruction. It is always set.
-- ins-\>dreg, ins-\>sreg1, ins-\>sreg2 contain the the destination and source vregs of the instruction. If the instruction doesn't have a destination/and our source, the corresponding field is set to -1.
+- ins-\>dreg, ins-\>sreg1, ins-\>sreg2 contain the destination and source vregs of the instruction. If the instruction doesn't have a destination/and our source, the corresponding field is set to -1.
- ins-\>backend is used for various purposes:
- for MonoInst's representing vtype variables, it indicates that the variable is in unmanaged format (used during marshalling)
diff --git a/docs/design/mono/web/soft-debugger-wire-format.md b/docs/design/mono/web/soft-debugger-wire-format.md
index 49facbc283df79..f49f395de0905d 100644
--- a/docs/design/mono/web/soft-debugger-wire-format.md
+++ b/docs/design/mono/web/soft-debugger-wire-format.md
@@ -392,7 +392,7 @@ Each command requires at least one TypeID (of type id) parameter before any addi
| GET_FIELD_CATTRS | 11 | Returns a list of custom attributes of a type's field. Custom attribute definition is given below. | Ask for a FieldID of one the type field and a TypeID of an custom attribute type | INVALID_TYPEID, INVALID_FIELDID |
| GET_PROPERTY_CATTRS | 12 | Returns a list of custom attributes of a type's property. Custom attribute definition is given below. | Ask for a PropertyID of one the type field and a TypeID of an custom attribute type | INVALID_TYPEID, INVALID_PROPERTYID |
| GET_SOURCE_FILES_2 | 13 | Returns a list of source file full paths (string) where the type is defined | None | INVALID_TYPEID |
-| GET_VALUES_2 | 14 | Returns a number of variant value equals to the number of FieldID that was passed as parameter. If the field had a ThreadStatic attribute applied to it, value fetched are from the thread parameter point of view. | Ask for an ObjectID representing a System.Thread instance and a list of FieldID representing this type static fields to the the value of. Only static field are supported. | INVALID_OBJECT, INVALID_TYPEID, INVALID_FIELDID |
+| GET_VALUES_2 | 14 | Returns a number of variant value equals to the number of FieldID that was passed as parameter. If the field had a ThreadStatic attribute applied to it, value fetched are from the thread parameter point of view. | Ask for an ObjectID representing a System.Thread instance and a list of FieldID representing this type static fields to the value of. Only static field are supported. | INVALID_OBJECT, INVALID_TYPEID, INVALID_FIELDID |
The main functions handling these commands are `type_commands` and `type_commands_internal` and are situated at `debugger-agent.c:6726` and `debugger-agent.c:6403` respectively.
diff --git a/docs/design/security/System.HashCode.md b/docs/design/security/System.HashCode.md
index fb177ac2d0c38d..946c611f409129 100644
--- a/docs/design/security/System.HashCode.md
+++ b/docs/design/security/System.HashCode.md
@@ -128,7 +128,7 @@ Concretely, in the face of adversarial input:
## Implementation
-The `HashCode` type uses the [**xxHash32**](https://github.com/Cyan4973/xxHash) algorithm, which is a non-cryptographic hash algorithm with a 32-bit seed and a 32-bit digest. All instances of the `HashCode` type use the same seed value, generated randomly at app start. This value is chosen independently of other random seed values in the runtime, such as the the global 64-bit seed used in `string.GetHashCode`'s Marvin32 routine.
+The `HashCode` type uses the [**xxHash32**](https://github.com/Cyan4973/xxHash) algorithm, which is a non-cryptographic hash algorithm with a 32-bit seed and a 32-bit digest. All instances of the `HashCode` type use the same seed value, generated randomly at app start. This value is chosen independently of other random seed values in the runtime, such as the global 64-bit seed used in `string.GetHashCode`'s Marvin32 routine.
The xxHash32 repo's README file touts good performance and avalanching. This can be validated through a simple C# program.
diff --git a/docs/design/tools/illink/compiler-generated-code-handling.md b/docs/design/tools/illink/compiler-generated-code-handling.md
index 4ed908db0eab76..df5661ea01ed96 100644
--- a/docs/design/tools/illink/compiler-generated-code-handling.md
+++ b/docs/design/tools/illink/compiler-generated-code-handling.md
@@ -95,6 +95,24 @@ static IEnumerable TestLocalVariable ()
}
```
+## Attribute propagation via CompilerLoweringPreserveAttribute
+
+To address the challenges of propagating user-authored attributes to compiler-generated code, .NET 10 introduced a general mechanism: `[CompilerLoweringPreserveAttribute]`. This attribute can be applied to other attribute types to instruct compilers to propagate those attributes to compiler-generated code.
+
+`DynamicallyAccessedMembersAttribute` is now marked with `[CompilerLoweringPreserve]`, so when the compiler generates new fields or type parameters (such as for local functions, iterator/async state machines, or primary constructor parameters), the relevant `DynamicallyAccessedMembers` annotations are automatically applied to the generated members. This allows trimming tools to directly use the annotations present in the generated code, without needing to reverse-engineer the mapping to user code.
+
+### .NET 10 and later
+
+For .NET 10 and later, trimming tools should rely on the compiler to propagate attributes such as `DynamicallyAccessedMembersAttribute` to all relevant compiler-generated code, as indicated by `[CompilerLoweringPreserve]`. No heuristics are needed for these assemblies. This isn't perfect because it's possible for such assemblies to be compiled with new Roslyn versions that could use different lowering strategies, so it's possible that the existing heuristics will break for new releases of a pre-`net10.0` assembly.
+
+To mitigate this there are a few options:
+
+1. Multitarget the library to `net10.0` (so that it is built with the new `CompilerLoweringPreserve` behavior and will avoid the heuristics)
+2. Fix the heuristics to work for code produced by new Roslyn versions
+3. The trimming tools could detect the presence of a polyfilled `DynamicallyAccessedMembersAttribute` type with `CompilerLoweringPreserve`. When present this would turn off the heuristics for the containing assembly.
+
+Another issue is that .NET 10 libraries might be built with `false`, and the tooling would not be able to detect the TargetFramework. Aside from setting `true`, mitigations 1. and 2. above would also apply to this scenario.
+
### Compiler dependent behavior
Since the problems are all caused by compiler generated code, the behaviors depend on the specific compiler in use. The main focus of this document is the Roslyn C# compiler right now. Mainly since it's by far the most used compiler for .NET code. That said, we would like to design the solution in such a way that other compilers using similar patterns could also benefit from it.
@@ -560,9 +578,9 @@ and fields on the closure types.
### Long term solution
Detecting which compiler generated items are used by any given user method is currently relatively tricky.
-There's no definitive marker in the IL which would let the trimmer confidently determine this information.
-Good long term solution will need the compilers to produce some kind of marker in the IL so that
-static analysis tools can reliably detect all of the compiler generated items.
+There's no definitive marker in the IL which would let the trimmer confidently determine this information
+for all of the above cases. Good long term solution will need the compilers to produce some kind of marker
+in the IL so that static analysis tools can reliably detect all of the compiler generated items.
This ask can be described as:
For a given user method, ability to determine all of the items (methods, fields, types, IL code) which were
@@ -573,6 +591,10 @@ helpers and other infrastructure which may be needed but is not directly attribu
This should be enough to implement solutions for both suppression propagation and data flow analysis.
+For `DynamicallyAccessedMembersAttribute`, we have a long-term solution that relies on the
+`[CompilerLoweringPreserve]` attribute, which tells Roslyn to propagate `DynamicallyAccessedMembers`
+annotations to compiler-generated code.
+
### Possible short term solution
#### Heuristic based solution
diff --git a/docs/project/list-of-diagnostics.md b/docs/project/list-of-diagnostics.md
index 0b3da600c53b13..bb6a670802c733 100644
--- a/docs/project/list-of-diagnostics.md
+++ b/docs/project/list-of-diagnostics.md
@@ -116,6 +116,7 @@ The PR that reveals the implementation of the ` are obsolete. Use the new ones that take an IComparer\. |
+| __`SYSLIB0062`__ | XSLT Script blocks are not supported. |
## Analyzer Warnings
@@ -296,7 +297,7 @@ The diagnostic id values reserved for .NET Libraries analyzer warnings are `SYSL
APIs can be marked as `[Experimental]` if their shape or functionality is included in a release but not yet officially supported. Experimental APIs offer the opportunity to collect customer feedback on these APIs in a major release, usually refining the APIs and removing the `[Experimental]` attribute in the next release. The `[Experimental]` attribute differs from `[RequiresPreviewFeatures]`, wherein:
* `[RequiresPreviewFeatures]` APIs require a corresponding preview feature in another product area such as the compiler or SDK
- - Using these APIs requires enabling preview features for the the project and all its consumers
+ - Using these APIs requires enabling preview features for the project and all its consumers
* `[Experimental]` APIs are self-contained within the libraries and do not require preview features in other parts of the product
- These APIs can be used by suppressing specific diagnostics without enabling preview features for the project
diff --git a/docs/workflow/building/coreclr/android.md b/docs/workflow/building/coreclr/android.md
index 3a6769d062acdc..473ee4a2b05a09 100644
--- a/docs/workflow/building/coreclr/android.md
+++ b/docs/workflow/building/coreclr/android.md
@@ -1,23 +1,29 @@
# Experimental support of CoreCLR on Android
-This is the internal documentation which outlines experimental support of CoreCLR on Android and includes instructions on how to:
-- [Build CoreCLR for Android](./android.md#building-coreclr-for-android)
-- [Build and run a sample application with CoreCLR](./android.md#building-and-running-a-sample-app)
-- [Debug the sample app and the runtime](./android.md#debugging-the-runtime-and-the-sample-app)
-
-## Prerequisite
-
-- Download and install [OpenJDK 23](https://openjdk.org/projects/jdk/23/)
-- Download and install [Android Studio](https://developer.android.com/studio/install) and the following:
- - Android SDK (minimum supported API level is 21)
- - Android NDK r27
-
-> [!NOTE]
-> Prerequisites can also be downloaded and installed manually:
-> - by running the automated script as described in [Testing Libraries on Android](../../testing/libraries/testing-android.md#using-a-terminal)
-> - by downloading the archives:
-> - Android SDK - Download [command-line tools](https://developer.android.com/studio#command-line-tools-only) and use `sdkmanager` to download the SDK.
-> - Android NDK - Download [NDK](https://developer.android.com/ndk/downloads)
+This is the internal documentation which outlines experimental support of CoreCLR on Android.
+
+## Table of Contents
+
+- [Prerequisite](#prerequisite)
+- [Building CoreCLR for Android](#building-coreclr-for-android)
+ - [MacOS and Linux](#macos-and-linux)
+ - [Requirements](#requirements)
+ - [Building the runtime, libraries and tools](#building-the-runtime-libraries-and-tools)
+ - [Windows + WSL2](#windows--wsl2)
+ - [Windows requirements](#windows-requirements)
+ - [WSL requirements](#wsl-requirements)
+ - [Building the runtime, libraries and tools](#building-the-runtime-libraries-and-tools-1)
+- [Building and running a sample app](#building-and-running-a-sample-app)
+ - [Building HelloAndroid sample](#building-helloandroid-sample)
+ - [Running HelloAndroid sample on an emulator](#running-helloandroid-sample-on-an-emulator)
+ - [WSL2](#wsl2)
+- [Building and running tests on an emulator](#building-and-running-tests-on-an-emulator)
+- [Debugging the runtime and the sample app](#debugging-the-runtime-and-the-sample-app)
+ - [Steps](#steps)
+- [See also](#see-also)
+- [Troubleshooting](#troubleshooting)
+ - [Android samples or functional tests fail to build](#android-samples-or-functional-tests-fail-to-build)
+ - [java.lang.NullPointerException: Cannot invoke String.length()](#javalangnullpointerexception-cannot-invoke-stringlength)
## Building CoreCLR for Android
@@ -34,11 +40,23 @@ Supported target architectures:
### MacOS and Linux
-#### Requirements
+#### Prerequisites
+
+- Download and install [OpenJDK 23](https://openjdk.org/projects/jdk/23/)
+- Download and install [Android Studio](https://developer.android.com/studio/install) and the following:
+ - Android SDK (minimum supported API level is 21)
+ - Android NDK r27c
+
+> [!NOTE]
+> Prerequisites can also be downloaded and installed manually:
+> - An automated script as described in [Testing Libraries on Android](../../testing/libraries/testing-android.md#using-a-terminal)
+> - Downloading the archives:
+> - Android SDK - Download [command-line tools](https://developer.android.com/studio#command-line-tools-only) and use `sdkmanager` to download the SDK.
+> - Android NDK - Download [NDK](https://developer.android.com/ndk/downloads)
Set the following environment variables:
- - ANDROID_SDK_ROOT=``
- - ANDROID_NDK_ROOT=``
+ - `export ANDROID_SDK_ROOT=`
+ - `export ANDROID_NDK_ROOT=`
#### Building the runtime, libraries and tools
@@ -57,22 +75,32 @@ To build CoreCLR runtime NuGet packages, run the following command from ` [!NOTE]
> The runtime packages will be located at: `/artifacts/packages//Shipping/`
-### Windows
+### Windows + WSL2
Building on Windows is not directly supported yet. However it is possible to use WSL2 for this purpose.
-#### WSL2
+#### Windows prerequisites
+
+- Download and install [Android Studio](https://developer.android.com/studio/install)
+- Enable [long paths](../../requirements/windows-requirements.md#enable-long-paths)
-##### Requirements
+#### WSL prerequisites
-1. Install the Android SDK and NDK in WSL per the [prerequisites](#prerequisite). This can be done by downloading the archives or using Android Studio.
+1. Follow [linux-requirements.md](../../requirements/linux-requirements.md).
+2. Install OpenJDK, Android SDK and Android NDK in as described in [Linux prerequisites](#prerequisites). There is a convenient automated script, but it can also be done manually by downloading the archives or using Android Studio.
- In case of Android Studio:
- Make sure WSL is updated: from Windows host, `wsl --update`
- [Enabled systemd](https://devblogs.microsoft.com/commandline/systemd-support-is-now-available-in-wsl/#set-the-systemd-flag-set-in-your-wsl-distro-settings)
- `sudo snap install android-studio --classic`
-2. Set the following environment variables:
- - ANDROID_SDK_ROOT=``
- - ANDROID_NDK_ROOT=``
+- For Ubuntu, OpenJDK 21 is sufficient:
+
+```
+apt install openjdk-21-jdk
+```
+
+3. Set the following environment variables:
+ - `export ANDROID_SDK_ROOT=`
+ - `export ANDROID_NDK_ROOT=`
#### Building the runtime, libraries and tools
@@ -84,9 +112,7 @@ To build CoreCLR runtime, libraries and tools, run the following command from `<
## Building and running a sample app
-To demonstrate building and running an Android sample application with CoreCLR, we will use:
-- the [HelloAndroid sample app](../../../../src/mono/sample/Android/AndroidSampleApp.csproj).
-- a functional tests [Android.Device_Emulator.JIT.Test](../../../../src/tests/FunctionalTests/Android/Device_Emulator/JIT/Android.Device_Emulator.JIT.Test.csproj)
+To demonstrate building and running an Android application with CoreCLR, we will use the [HelloAndroid sample app](../../../../src/mono/sample/Android/AndroidSampleApp.csproj).
A prerequisite for building and running samples locally is to have CoreCLR successfully built for desired Android platform.
@@ -128,30 +154,24 @@ The app can be run on an emulator running on the Windows host.
2. In Windows, create and start an emulator
3. In WSL, swap the `adb` from the Android SDK in WSL2 with that from Windows
- `mv $ANDROID_SDK_ROOT/platform-tools/adb $ANDROID_SDK_ROOT/platform-tools/adb-orig`
- - `ln -s /mnt/ $ANDROID_SDK_ROOT/platform-tools/adb`
+ - `ln -s /mnt//platform-tools/adb.exe $ANDROID_SDK_ROOT/platform-tools/adb`
+ - On Windows host, you can find the SDK location in Android Studio's SDK Manager.
4. In WSL, Make xharness use the `adb` corresponding to the Windows host:
- `export ADB_EXE_PATH=$ANDROID_SDK_ROOT/platform-tools/adb`
5. In WSL, run the `make` command as [above](#running-helloandroid-sample-on-an-emulator)
-### Building and running functional tests on an emulator
+## Building and running tests on an emulator
-Similarly to the `HelloAndroid` sample, it is possible to build and run a functional test on Android with CoreCLR on an emulator.
+To demonstrate building and running tests on CoreCLR Android, we will use the [Android.Device_Emulator.JIT.Test](../../../../src/tests/FunctionalTests/Android/Device_Emulator/JIT/Android.Device_Emulator.JIT.Test.csproj) test project.
-To build and run a functional test on Android with CoreCLR, run the following command from ``:
+To build and run the test on Android with CoreCLR, run the following command from ``:
```
-./dotnet.sh build -c Release src/tests/FunctionalTests/Android/Device_Emulator/JIT/Android.Device_Emulator.JIT.Test.csproj /p:TargetOS=android /p:TargetArchitecture=arm64 /t:Test /p:RuntimeFlavor=coreclr
+./dotnet.sh build -c src/tests/FunctionalTests/Android/Device_Emulator/JIT/Android.Device_Emulator.JIT.Test.csproj /p:TargetOS=android /p:TargetArchitecture= /t:Test /p:RuntimeFlavor=coreclr
```
> [!NOTE]
-> Similarly to the `HelloAndroid` sample the emulator needs to be up and running.
-
-### Useful make commands
-
-For convenience it is possible to run a single make command which builds all required dependencies, the app and runs it:
-```
-make BUILD_CONFIG= TARGET_ARCH= RUNTIME_FLAVOR=CoreCLR DEPLOY_AND_RUN=true all -C src/mono/sample/Android
-```
+> Similarly to the `HelloAndroid` sample, the emulator needs to be up and running.
## Debugging the runtime and the sample app
@@ -191,6 +211,8 @@ Similar instructions for debugging Android apps with Mono runtime can be found [
### Android samples or functional tests fail to build
+#### java.lang.NullPointerException: Cannot invoke String.length()
+
If multiple JDKs are installed on your system, you may encounter the following error:
```
diff --git a/docs/workflow/requirements/linux-requirements.md b/docs/workflow/requirements/linux-requirements.md
index cb22d31172780a..c2831776940417 100644
--- a/docs/workflow/requirements/linux-requirements.md
+++ b/docs/workflow/requirements/linux-requirements.md
@@ -95,6 +95,10 @@ If you're planning to use your environment to do Linux cross-building to other a
- `qemu`
- `qemu-user-static`
+```bash
+apt install binfmt-support debootstrap qemu qemu-user-static
+```
+
### Fedora
These instructions are written assuming *Fedora 40*.
diff --git a/docs/workflow/requirements/macos-requirements.md b/docs/workflow/requirements/macos-requirements.md
index 67e7840a64d1be..cd1aed4b8f142b 100644
--- a/docs/workflow/requirements/macos-requirements.md
+++ b/docs/workflow/requirements/macos-requirements.md
@@ -18,7 +18,6 @@ To build the runtime repo, you will also need to install the following dependenc
- `CMake` 3.20 or newer
- `icu4c`
-- `openssl@1.1` or `openssl@3`
- `pkg-config`
- `python3`
- `ninja` (This one is optional. It is an alternative tool to `make` for building native code)
diff --git a/docs/workflow/requirements/windows-requirements.md b/docs/workflow/requirements/windows-requirements.md
index aa2c54c3976a18..922824f274bb9f 100644
--- a/docs/workflow/requirements/windows-requirements.md
+++ b/docs/workflow/requirements/windows-requirements.md
@@ -46,9 +46,9 @@ It is highly recommended to use the *Workloads* approach, as that installs the f
- .NET desktop development
- Desktop development with C++
-To build the tests and do ARM32/ARM64 development, you'll need some additional components. You can find them by clicking on the *Individual components* tab in the *Visual Studio Installer*:
+To build the tests and do ARM64 development, you'll need some additional components. You can find them by clicking on the *Individual components* tab in the *Visual Studio Installer*:
-- For ARM stuff: *MSVC v143 - VS 2022 C++ ARM64/ARM64EC build tools (Latest)* for Arm64, and *MSVC v143 - VS 2022 C++ ARM build tools (Latest)* for Arm32.
+- For Arm64: *MSVC v143 - VS 2022 C++ ARM64/ARM64EC build tools (Latest)*
- For building tests: *C++/CLI support for v143 build tools (Latest)*
Alternatively, there is also a `.vsconfig` file included at the root of the runtime repo. It includes all the necessary components required, outlined in a JSON format that Visual Studio can read and parse. You can boot up Visual Studio directly and [import this `.vsconfig` file](https://learn.microsoft.com/visualstudio/install/import-export-installation-configurations?view=vs-2022#import-a-configuration) instead of installing the workloads yourself. It is worth mentioning however, that while we are very careful in maintaining this file up-to-date, sometimes it might get a tad obsolete and miss important components. So, it is always a good idea to double check that the full workloads are installed.
diff --git a/docs/workflow/testing/coreclr/running-arm32-tests.md b/docs/workflow/testing/coreclr/running-arm32-tests.md
new file mode 100644
index 00000000000000..c7bac99960c921
--- /dev/null
+++ b/docs/workflow/testing/coreclr/running-arm32-tests.md
@@ -0,0 +1,36 @@
+# Running ARM32 tests on modern hardware
+
+One of our supported targets is 32-bit ARM. It can be quite challenging to construct a realistic ARM32 environment where you can build or run tests in a reasonable amount of time. Thankfully, it's possible to configure an ARM64 linux environment so that you can cross-build from ARM64 to ARM32, and run tests there using native hardware support instead of software emulation. This is not possible on ARM64-based Windows (this functionality is not offered by the OS).
+
+## Configuring your ARM64 environment to run ARM32 binaries
+
+By default your ARM64 Linux install probably doesn't have support for ARM32 binaries enabled, which will cause running the binaries to fail with a cryptic error. So you'll need to add the architecture to dpkg and install some core userspace libraries that CoreCLR will need to actually run your tests, which on Debian or Ubuntu will look like:
+
+```bash
+$ sudo dpkg --add-architecture armhf
+
+$ sudo apt-get update
+Reading package lists... Done
+
+$ sudo apt-get install libc6:armhf libstdc++6:armhf libicu74:armhf
+The following additional packages will be installed:
+```
+
+Note that when installing a package for another architecture, you need to suffix the package name with the architecture name. For me, the three packages above were sufficient to run an ARM32 JIT test.
+
+## Cross-building for ARM32 on ARM64
+
+Follow the steps from https://github.com/dotnet/runtime/blob/main/docs/workflow/building/coreclr/cross-building.md#linux-cross-building as-is. You should end up with a `linux.arm` `Core_Root` and test artifacts.
+
+## Running an ARM32 test in your ARM64 environment
+
+We're finally ready to go, probably. Export an environment variable to point to your ARM32 core root, and then run your test, i.e.:
+
+```bash
+$ export CORE_ROOT=/home/kg/runtime/artifacts/tests/coreclr/linux.arm.Release/Tests/Core_Root/
+
+$ bash artifacts/tests/coreclr/linux.arm.Release/JIT/Directed/StructABI/StructABI/StructABI.sh
+BEGIN EXECUTION
+/home/kg/runtime/artifacts/tests/coreclr/linux.arm.Release/Tests/Core_Root//corerun -p System.Reflection.Metadata.MetadataUpdater.IsSupported=false -p System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization=true StructABI.dll ''
+Issue80393_HFA failed. Retval: f1=1 f3=3
+```
diff --git a/docs/workflow/testing/libraries/testing-android.md b/docs/workflow/testing/libraries/testing-android.md
index 9b138a0b61b5b1..1afa6786c46199 100644
--- a/docs/workflow/testing/libraries/testing-android.md
+++ b/docs/workflow/testing/libraries/testing-android.md
@@ -23,9 +23,9 @@ Android SDK and NDK can be automatically installed via the following script:
set -e
NDK_VER=r27c
-SDK_VER=9123335_latest
-SDK_API_LEVEL=33
-SDK_BUILD_TOOLS=33.0.1
+ANDROID_CLI_TOOLS_VER=13114758_latest
+SDK_API_LEVEL=36
+SDK_BUILD_TOOLS=36.0.0
if [[ "$OSTYPE" == "darwin"* ]]; then
HOST_OS=darwin
@@ -45,7 +45,7 @@ unzip ~/andk.zip -d $(dirname ${ANDROID_NDK_ROOT}) && rm -rf ~/andk.zip
# download Android SDK, accept licenses and download additional packages such as
# platform-tools, platforms and build-tools
export ANDROID_SDK_ROOT=~/android-sdk
-curl https://dl.google.com/android/repository/commandlinetools-${HOST_OS_SHORT}-${SDK_VER}.zip -L --output ~/asdk.zip
+curl https://dl.google.com/android/repository/commandlinetools-${HOST_OS_SHORT}-${ANDROID_CLI_TOOLS_VER}.zip -L --output ~/asdk.zip
mkdir ${ANDROID_SDK_ROOT} && unzip ~/asdk.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools && rm -rf ~/asdk.zip
yes | ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools/bin/sdkmanager --sdk_root=${ANDROID_SDK_ROOT} --licenses
${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools/bin/sdkmanager --sdk_root=${ANDROID_SDK_ROOT} "platform-tools" "platforms;android-${SDK_API_LEVEL}" "build-tools;${SDK_BUILD_TOOLS}"
diff --git a/docs/workflow/testing/using-dev-shipping-packages.md b/docs/workflow/testing/using-dev-shipping-packages.md
index d09bd7b27f6fbd..2c90c1e0118a6e 100644
--- a/docs/workflow/testing/using-dev-shipping-packages.md
+++ b/docs/workflow/testing/using-dev-shipping-packages.md
@@ -118,11 +118,9 @@ Console.WriteLine($"The location of System.Private.CoreLib.dll is '{typeof(objec
The following command will build and publish your app:
```cmd
-dotnet publish -r win-x64
+dotnet publish --self-contained
```
-Adjust the `win-x64` to match your machine's OS and architecture.
-
Running this little app should yield an output like the following:
```text
diff --git a/eng/SignCheckExclusionsFile.txt b/eng/SignCheckExclusionsFile.txt
deleted file mode 100644
index f41753338155eb..00000000000000
--- a/eng/SignCheckExclusionsFile.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-;; Exclusions for SignCheck. Corresponds to info in Signing.props.
-;; Format: https://github.com/dotnet/arcade/blob/397316e195639450b6c76bfeb9823b40bee72d6d/src/SignCheck/Microsoft.SignCheck/Verification/Exclusion.cs#L23-L35
-;;
-;; This issue tracks a way to implement exclusions via Signing.props and avoid this extra file: https://github.com/dotnet/arcade/issues/2888
-
-;; The apphost and comhost are template files, modified by the SDK to produce the executable for FDE
-;; and SCD apps. If they are signed, the file that the SDK produces has an invalid signature and
-;; can't be signed again. More info at https://github.com/dotnet/core-setup/pull/7549.
-*apphost.exe;;Template, DO-NOT-SIGN, https://github.com/dotnet/core-setup/pull/7549
-*singlefilehost.exe;;Template, DO-NOT-SIGN, https://github.com/dotnet/core-setup/pull/7549
-*comhost.dll;;Template, DO-NOT-SIGN, https://github.com/dotnet/core-setup/pull/7549
-*apphosttemplateapphostexe.exe;;Template, DO-NOT-SIGN, https://github.com/dotnet/core-setup/pull/7549
-*comhosttemplatecomhostdll.dll;;Template, DO-NOT-SIGN, https://github.com/dotnet/core-setup/pull/7549
-*staticapphosttemplateapphostexe.exe;;Template, DO-NOT-SIGN, https://github.com/dotnet/core-setup/pull/7549
-*dotnet.js;;Workaround, https://github.com/dotnet/core-eng/issues/9933
\ No newline at end of file
diff --git a/eng/Subsets.props b/eng/Subsets.props
index c0d6664a1fc7d4..5770eec315eb4d 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -47,7 +47,7 @@
true
- <_NativeAotSupportedOS Condition="'$(TargetOS)' == 'windows' or '$(TargetOS)' == 'linux' or '$(TargetOS)' == 'osx' or '$(TargetOS)' == 'maccatalyst' or '$(TargetOS)' == 'iossimulator' or '$(TargetOS)' == 'ios' or '$(TargetOS)' == 'tvossimulator' or '$(TargetOS)' == 'tvos' or '$(TargetOS)' == 'freebsd'">true
+ <_NativeAotSupportedOS Condition="'$(TargetOS)' != 'browser' and '$(TargetOS)' != 'haiku' and '$(TargetOS)' != 'illumos' and '$(TargetOS)' != 'netbsd' and '$(TargetOS)' != 'solaris'">true
<_NativeAotSupportedArch Condition="'$(TargetArchitecture)' == 'x64' or '$(TargetArchitecture)' == 'arm64' or '$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'loongarch64' or '$(TargetArchitecture)' == 'riscv64' or ('$(TargetOS)' == 'windows' and '$(TargetArchitecture)' == 'x86')">true
true
@@ -71,6 +71,7 @@
clr+mono+libs+tools+host+packsmono+libs+packsclr+mono+libs+host+packs
+ clr.nativeaotruntime+clr.nativeaotlibs+mono+libs+packsclr.nativeaotruntime+clr.nativeaotlibs+mono+libs+packsclr.nativeaotruntime+clr.nativeaotlibs+mono+libs+host+packsclr.nativeaotruntime+clr.nativeaotlibs+libs+packs
@@ -153,9 +154,21 @@
$(BootstrapSubsets)+clr.nativeaotlibs+clr.nativeaotruntime+libs.nativetrue
+
+
+ clr.nativeprereqs+clr.iltools+clr.runtime+clr.native+clr.aot+clr.nativeaotlibs+clr.nativeaotruntime+clr.crossarchtools
+ $(AllSubsetsExpansion)+clr.paltests+clr.paltestlist+clr.hosts+clr.jit+clr.alljits+clr.alljitscommunity+clr.spmi+clr.corelib+clr.nativecorelib+clr.tools+clr.toolstests+clr.packages
+ $(AllSubsetsExpansion)+linuxdac+alpinedac
+ $(AllSubsetsExpansion)+mono.runtime+mono.emsdk+mono.aotcross+mono.corelib+mono.manifests+mono.packages+mono.tools+mono.wasmruntime+mono.wasiruntime+mono.wasmworkload+mono.mscordbi+mono.workloads
+ $(AllSubsetsExpansion)+tools.illink+tools.cdac+tools.illinktests+tools.cdactests
+ $(AllSubsetsExpansion)+host.native+host.pkg+host.tools+host.pretest+host.tests
+ $(AllSubsetsExpansion)+libs.native+libs.sfx+libs.oob+libs.pretest+libs.tests
+ $(AllSubsetsExpansion)+packs.product+packs.installers+packs.tests
+ $(AllSubsetsExpansion)+regeneratedownloadtable+regeneratethirdpartynotices+tasks
+ <_subset>$(_subset.Replace('+allsubsets+', '+$(AllSubsetsExpansion)+'))
<_subset>$(_subset.Replace('+clr.paltests+', '+clr.paltests+clr.paltestlist+'))
<_subset>$(_subset.Replace('+clr+', '+$(DefaultCoreClrSubsets)+'))
<_subset>$(_subset.Replace('+clr.aot+', '+$(DefaultNativeAotSubsets)+'))
@@ -264,6 +277,9 @@
+
+
+
@@ -640,8 +656,9 @@
<_BuildCoreCLRRuntimePack Condition="'$(RuntimeFlavor)' == 'CoreCLR' and '$(CoreCLRSupported)' == 'true'">true
<_BuildMonoRuntimePack Condition="'$(RuntimeFlavor)' == 'Mono' and '$(MonoSupported)' == 'true'">true
<_BuildHostPack Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'">true
- <_BuildCdacPack Condition="'$(_CDacToolsBuilt)' == 'true' and '$(RuntimeFlavor)' == 'CoreCLR' and '$(TargetsMobile)' != 'true' and '$(TargetsLinuxMusl)' != 'true' and ('$(TargetOS)' == 'windows' or '$(TargetOS)' == 'osx' or '$(TargetOS)' == 'linux')">true
- <_BuildCdacPack Condition="'$(DotNetBuildSourceOnly)' == 'true' or '$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'armel' or '$(TargetArchitecture)' == 'x86' or '$(TargetArchitecture)' == 'riscv64'">false
+ <_BuildCdacPack Condition="'$(_CDacToolsBuilt)' == 'true' and '$(RuntimeFlavor)' == 'CoreCLR' and '$(TargetsMobile)' != 'true' and ('$(TargetOS)' == 'windows' or '$(TargetOS)' == 'osx' or '$(TargetOS)' == 'linux')">true
+
+ <_BuildCdacPack Condition="'$(DotNetBuildSourceOnly)' == 'true' or '$(TargetsLinuxMusl)' == 'true'">false
<_BuildBundle Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'">true
diff --git a/eng/Version.Details.props b/eng/Version.Details.props
new file mode 100644
index 00000000000000..eebe1bbe032748
--- /dev/null
+++ b/eng/Version.Details.props
@@ -0,0 +1,237 @@
+
+
+
+
+
+ 10.0.0-preview.6.25302.1
+
+ 4.9.0-rc2.21473.1
+
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+ 19.1.0-alpha.1.25167.1
+
+ 5.0.0-2.25418.105
+ 5.0.0-2.25418.105
+ 5.0.0-2.25418.105
+ 10.0.0-preview.25418.105
+ 10.0.100-rc.1.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 0.11.5-alpha.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 10.0.0-beta.25418.105
+ 2.9.3-beta.25418.105
+ 2.9.3-beta.25418.105
+ 10.0.0-beta.25418.105
+ 5.0.0-2.25418.105
+ 10.0.0-rc.1.25418.105
+ 10.0.100-rc.1.25418.105
+ 10.0.0-rc.1.25418.105
+ 10.0.0-rc.1.25418.105
+ 7.0.0-preview.1.41905
+ 7.0.0-preview.1.41905
+ 7.0.0-preview.1.41905
+ 7.0.0-preview.1.41905
+ 10.0.0-rc.1.25418.105
+ 2.0.0-rc.1.25418.105
+ 10.0.0-rc.1.25418.105
+ 10.0.0-rc.1.25418.105
+ 10.0.0-rc.1.25418.105
+
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+ 10.0.0-beta.25310.1
+
+ 10.0.0-prerelease.25405.1
+ 10.0.0-prerelease.25405.1
+ 10.0.0-prerelease.25405.1
+
+ 1.0.0-prerelease.25413.5
+ 1.0.0-prerelease.25413.5
+ 1.0.0-prerelease.25413.5
+ 1.0.0-prerelease.25413.5
+ 1.0.0-prerelease.25413.5
+ 1.0.0-prerelease.25413.5
+
+ 10.0.0-alpha.0.25302.2
+
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+ 10.0.0-alpha.1.25169.1
+
+
+
+
+ $(MicrosoftNETCoreRuntimeICUTransportPackageVersion)
+
+ $(SystemServiceModelPrimitivesPackageVersion)
+
+ $(runtimelinuxarm64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+ $(runtimelinuxmuslarm64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimelinuxmuslarm64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimelinuxmuslarm64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimelinuxmuslarm64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+ $(runtimelinuxmuslx64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimelinuxmuslx64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimelinuxmuslx64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimelinuxmuslx64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+ $(runtimelinuxx64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+ $(runtimeosxarm64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimeosxarm64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimeosxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimeosxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+ $(runtimeosxx64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimeosxx64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimeosxx64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimeosxx64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+ $(runtimewinarm64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimewinx64MicrosoftNETCoreRuntimeJITToolsPackageVersion)
+ $(runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMLibclangPackageVersion)
+ $(runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkPackageVersion)
+ $(runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsPackageVersion)
+
+ $(MicrosoftCodeAnalysisPackageVersion)
+ $(MicrosoftCodeAnalysisAnalyzersPackageVersion)
+ $(MicrosoftCodeAnalysisCSharpPackageVersion)
+ $(MicrosoftCodeAnalysisNetAnalyzersPackageVersion)
+ $(MicrosoftDotNetApiCompatTaskPackageVersion)
+ $(MicrosoftDotNetArcadeSdkPackageVersion)
+ $(MicrosoftDotNetBuildTasksArchivesPackageVersion)
+ $(MicrosoftDotNetBuildTasksFeedPackageVersion)
+ $(MicrosoftDotNetBuildTasksInstallersPackageVersion)
+ $(MicrosoftDotNetBuildTasksPackagingPackageVersion)
+ $(MicrosoftDotNetBuildTasksTargetFrameworkPackageVersion)
+ $(MicrosoftDotNetBuildTasksTemplatingPackageVersion)
+ $(MicrosoftDotNetBuildTasksWorkloadsPackageVersion)
+ $(MicrosoftDotNetCecilPackageVersion)
+ $(MicrosoftDotNetCodeAnalysisPackageVersion)
+ $(MicrosoftDotNetGenAPIPackageVersion)
+ $(MicrosoftDotNetGenFacadesPackageVersion)
+ $(MicrosoftDotNetHelixSdkPackageVersion)
+ $(MicrosoftDotNetPackageTestingPackageVersion)
+ $(MicrosoftDotNetRemoteExecutorPackageVersion)
+ $(MicrosoftDotNetSharedFrameworkSdkPackageVersion)
+ $(MicrosoftDotNetXliffTasksPackageVersion)
+ $(MicrosoftDotNetXUnitAssertPackageVersion)
+ $(MicrosoftDotNetXUnitConsoleRunnerPackageVersion)
+ $(MicrosoftDotNetXUnitExtensionsPackageVersion)
+ $(MicrosoftNetCompilersToolsetPackageVersion)
+ $(MicrosoftNETSdkILPackageVersion)
+ $(MicrosoftNETWorkloadEmscriptenCurrentManifest100100TransportPackageVersion)
+ $(MicrosoftNETCoreAppRefPackageVersion)
+ $(MicrosoftNETCoreILAsmPackageVersion)
+ $(NuGetFrameworksPackageVersion)
+ $(NuGetPackagingPackageVersion)
+ $(NuGetProjectModelPackageVersion)
+ $(NuGetVersioningPackageVersion)
+ $(runtimenativeSystemIOPortsPackageVersion)
+ $(SystemCommandLinePackageVersion)
+ $(SystemReflectionMetadataPackageVersion)
+ $(SystemReflectionMetadataLoadContextPackageVersion)
+ $(SystemTextJsonPackageVersion)
+
+ $(MicrosoftDotNetCilStripSourcesPackageVersion)
+ $(MicrosoftNETHostModelTestDataPackageVersion)
+ $(SystemComponentModelTypeConverterTestDataPackageVersion)
+ $(SystemDataCommonTestDataPackageVersion)
+ $(SystemDrawingCommonTestDataPackageVersion)
+ $(SystemFormatsTarTestDataPackageVersion)
+ $(SystemIOCompressionTestDataPackageVersion)
+ $(SystemIOPackagingTestDataPackageVersion)
+ $(SystemNetTestDataPackageVersion)
+ $(SystemPrivateRuntimeUnicodeDataPackageVersion)
+ $(SystemRuntimeNumericsTestDataPackageVersion)
+ $(SystemRuntimeTimeZoneDataPackageVersion)
+ $(SystemSecurityCryptographyX509CertificatesTestDataPackageVersion)
+ $(SystemTextRegularExpressionsTestDataPackageVersion)
+ $(SystemWindowsExtensionsTestDataPackageVersion)
+
+ $(MicrosoftDotNetXHarnessCLIPackageVersion)
+ $(MicrosoftDotNetXHarnessTestRunnersCommonPackageVersion)
+ $(MicrosoftDotNetXHarnessTestRunnersXunitPackageVersion)
+
+ $(optimizationlinuxarm64MIBCRuntimePackageVersion)
+ $(optimizationlinuxx64MIBCRuntimePackageVersion)
+ $(optimizationPGOCoreCLRPackageVersion)
+ $(optimizationwindows_ntarm64MIBCRuntimePackageVersion)
+ $(optimizationwindows_ntx64MIBCRuntimePackageVersion)
+ $(optimizationwindows_ntx86MIBCRuntimePackageVersion)
+
+ $(MicrosoftDotNetHotReloadUtilsGeneratorBuildToolPackageVersion)
+
+ $(runtimelinuxarm64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimelinuxmuslarm64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimelinuxmuslx64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimelinuxx64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimeosxarm64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimeosxx64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimewinarm64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+ $(runtimewinx64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)
+
+
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index cc791158eb2c5c..2ea152526c443f 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -1,5 +1,5 @@
-
+ https://github.com/dotnet/icu
@@ -41,91 +41,91 @@
https://github.com/dotnet/llvm-projectda5dd054a531e6fea65643b7e754285b73eab433
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301https://github.com/dotnet/runtime-assets
@@ -263,65 +263,65 @@
https://github.com/dotnet/llvm-projectda5dd054a531e6fea65643b7e754285b73eab433
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/xharness
- e85bb14e85357ab678c2bcb0b6f2bac634fdd49b
+ 4c17e23fcb7575baa9de575e5a96258096cbaea1
-
+ https://github.com/dotnet/xharness
- e85bb14e85357ab678c2bcb0b6f2bac634fdd49b
+ 4c17e23fcb7575baa9de575e5a96258096cbaea1
-
+ https://github.com/dotnet/xharness
- e85bb14e85357ab678c2bcb0b6f2bac634fdd49b
+ 4c17e23fcb7575baa9de575e5a96258096cbaea1
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://dev.azure.com/dnceng/internal/_git/dotnet-optimization
- a68196f69e40740fce716778138acaa26488b333
+ e7f12ca10fc5b13e4ebc33244b585081da7f8bfb
-
+ https://dev.azure.com/dnceng/internal/_git/dotnet-optimization
- a68196f69e40740fce716778138acaa26488b333
+ e7f12ca10fc5b13e4ebc33244b585081da7f8bfb
-
+ https://dev.azure.com/dnceng/internal/_git/dotnet-optimization
- a68196f69e40740fce716778138acaa26488b333
+ e7f12ca10fc5b13e4ebc33244b585081da7f8bfb
-
+ https://dev.azure.com/dnceng/internal/_git/dotnet-optimization
- a68196f69e40740fce716778138acaa26488b333
+ e7f12ca10fc5b13e4ebc33244b585081da7f8bfbhttps://github.com/dotnet/hotreload-utils
@@ -331,55 +331,55 @@
https://github.com/dotnet/runtime-assets385d085eb055cabeaed3dde958a900e7b31cf6ce
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://github.com/dotnet/dotnet
- eaa19c281d34580a8168cff9ce1e7337da8bfe4f
+ 5c3434d8b831745673c31e186906f463e1036301
-
+ https://dev.azure.com/dnceng/internal/_git/dotnet-optimization
- a68196f69e40740fce716778138acaa26488b333
+ e7f12ca10fc5b13e4ebc33244b585081da7f8bfb
-
+ https://dev.azure.com/dnceng/internal/_git/dotnet-optimization
- a68196f69e40740fce716778138acaa26488b333
+ e7f12ca10fc5b13e4ebc33244b585081da7f8bfb
-
- https://github.com/NuGet/NuGet.Client
- 8fef55f5a55a3b4f2c96cd1a9b5ddc51d4b927f8
+
+ https://github.com/dotnet/dotnet
+ 5c3434d8b831745673c31e186906f463e1036301
-
- https://github.com/NuGet/NuGet.Client
- 8fef55f5a55a3b4f2c96cd1a9b5ddc51d4b927f8
+
+ https://github.com/dotnet/dotnet
+ 5c3434d8b831745673c31e186906f463e1036301
-
- https://github.com/NuGet/NuGet.Client
- 8fef55f5a55a3b4f2c96cd1a9b5ddc51d4b927f8
+
+ https://github.com/dotnet/dotnet
+ 5c3434d8b831745673c31e186906f463e1036301
-
- https://github.com/NuGet/NuGet.Client
- 8fef55f5a55a3b4f2c96cd1a9b5ddc51d4b927f8
+
+ https://github.com/dotnet/dotnet
+ 5c3434d8b831745673c31e186906f463e1036301https://github.com/dotnet/node
diff --git a/eng/Versions.props b/eng/Versions.props
index 414939064fe53a..d61001668130e5 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -1,4 +1,5 @@
+ 10.0.0
@@ -11,8 +12,8 @@
8.0.$([MSBuild]::Add($([System.Version]::Parse('$(PackageVersionNet9)').Build),11))7.0.206.0.36
- preview
- 7
+ rc
+ 1falserelease
@@ -28,26 +29,11 @@
truetrue
-
- true
+ true
-
-
- 10.0.0-preview.25351.106
-
- 5.0.0-1.25351.106
-
- 5.0.0-1.25351.106
- 5.0.0-1.25351.106
- 5.0.0-1.25351.106
-
- 10.0.100-preview.7.25351.106
-
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 2.9.2-beta.25351.106
- 10.0.0-beta.25351.106
- 2.9.2-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
- 10.0.0-beta.25351.106
-
- 1.4.06.0.0-preview.1.102
- 10.0.0-preview.7.25351.1066.0.0
-
- 10.0.0-preview.7.25351.106
- 10.0.0-preview.7.25351.1066.0.04.6.1
@@ -128,16 +89,12 @@
8.0.08.0.15.0.0
- 10.0.0-preview.7.25351.106
- 10.0.0-preview.7.25351.1066.0.05.0.05.0.05.0.07.0.0
- 10.0.0-preview.7.25351.1067.0.0
- 10.0.0-preview.7.25351.1068.0.04.5.1
@@ -148,39 +105,9 @@
8.0.08.0.04.5.4
-
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
- 10.0.0-beta.25310.1
-
- 10.0.0-prerelease.25255.1
- 10.0.0-prerelease.25255.1
- 10.0.0-prerelease.25255.1
-
- 10.0.0-alpha.0.25302.2
-
- 1.0.0-prerelease.25256.1
- 1.0.0-prerelease.25256.1
- 1.0.0-prerelease.25256.1
- 1.0.0-prerelease.25256.1
- 1.0.0-prerelease.25256.1
- 1.0.0-prerelease.25256.12.0.017.10.0-beta1.24272.1
- 2.0.0-beta6.25351.1063.1.162.1.02.0.3
@@ -190,10 +117,6 @@
17.8.317.8.317.8.3
- 6.2.4
- 6.2.4
- 6.2.4
- 6.2.47.0.4127016.0
@@ -206,7 +129,6 @@
7.0.213.0.31.0.2
- 2.0.44.18.48.0.22.14.3
@@ -225,60 +147,23 @@
17.0.469.0.0-preview-20241010.1
-
- 0.11.5-alpha.25351.106
-
- 10.0.0-preview.6.25302.12.4.89.0.0-alpha.1.24167.3
-
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 10.0.100-preview.7.25351.106$(MicrosoftNETWorkloadEmscriptenCurrentManifest100100TransportVersion)1.1.87-gba258badda1.0.0-v3.14.0.5722
-
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.1
- 19.1.0-alpha.1.25167.13.1.71.0.406601$(MicrosoftDotNetApiCompatTaskVersion)
- 10.0.0-alpha.1.25169.1
- 10.0.0-preview.4.25217.3
+ 10.0.0-preview.7.25359.101$(runtimewinx64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion)3.1.56
diff --git a/eng/build.ps1 b/eng/build.ps1
index e6810524b6357a..f642b35f228900 100644
--- a/eng/build.ps1
+++ b/eng/build.ps1
@@ -176,8 +176,8 @@ if ($vs) {
}
# Auto-generated solution file that still uses the sln format
- if ($vs -ieq "coreclr.sln") {
- # If someone passes in coreclr.sln (case-insensitive),
+ if ($vs -ieq "coreclr.sln" -or $vs -ieq "coreclr") {
+ # If someone passes in coreclr.sln or just coreclr (case-insensitive),
# launch the generated CMake solution.
$vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "artifacts\obj\coreclr" | Join-Path -ChildPath "windows.$archToOpen.$((Get-Culture).TextInfo.ToTitleCase($configToOpen))" | Join-Path -ChildPath "ide" | Join-Path -ChildPath "CoreCLR.sln"
if (-Not (Test-Path $vs)) {
@@ -192,7 +192,7 @@ if ($vs) {
}
}
# Auto-generated solution file that still uses the sln format
- elseif ($vs -ieq "corehost.sln") {
+ elseif ($vs -ieq "corehost.sln" -or $vs -ieq "corehost") {
$vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "artifacts\obj\" | Join-Path -ChildPath "win-$archToOpen.$((Get-Culture).TextInfo.ToTitleCase($configToOpen))" | Join-Path -ChildPath "corehost" | Join-Path -ChildPath "ide" | Join-Path -ChildPath "corehost.sln"
if (-Not (Test-Path $vs)) {
Invoke-Expression "& `"$repoRoot/eng/common/msbuild.ps1`" $repoRoot/src/native/corehost/corehost.proj /clp:nosummary /restore /p:Ninja=false /p:Configuration=$configToOpen /p:TargetArchitecture=$archToOpen /p:ConfigureOnly=true"
@@ -214,6 +214,11 @@ if ($vs) {
} else {
# Search for the solution in coreclr
$vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\coreclr" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.slnx"
+
+ # Also, search for the solution in coreclr\tools\aot
+ if (-Not (Test-Path $vs)) {
+ $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\coreclr\tools\aot\$solution.slnx"
+ }
}
if (-Not (Test-Path $vs)) {
diff --git a/eng/build.sh b/eng/build.sh
index 294afc4031dd50..2a79304978faae 100755
--- a/eng/build.sh
+++ b/eng/build.sh
@@ -150,7 +150,7 @@ initDistroRid()
showSubsetHelp()
{
- "$scriptroot/common/build.sh" "-restore" "-build" "/p:Subset=help" "/clp:nosummary /tl:false"
+ "$scriptroot/common/build.sh" "-restore" "-build" "/p:Subset=help" "/clp:nosummary" "/tl:false"
}
arguments=()
diff --git a/eng/common/SetupNugetSources.ps1 b/eng/common/SetupNugetSources.ps1
index 5db4ad71ee2f3e..792b60b49d424d 100644
--- a/eng/common/SetupNugetSources.ps1
+++ b/eng/common/SetupNugetSources.ps1
@@ -10,8 +10,8 @@
# displayName: Setup Private Feeds Credentials
# condition: eq(variables['Agent.OS'], 'Windows_NT')
# inputs:
-# filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
-# arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+# filePath: $(System.DefaultWorkingDirectory)/eng/common/SetupNugetSources.ps1
+# arguments: -ConfigFile $(System.DefaultWorkingDirectory)/NuGet.config -Password $Env:Token
# env:
# Token: $(dn-bot-dnceng-artifact-feeds-rw)
#
diff --git a/eng/common/SetupNugetSources.sh b/eng/common/SetupNugetSources.sh
index 4604b61b0323ae..facb415ca6ff35 100755
--- a/eng/common/SetupNugetSources.sh
+++ b/eng/common/SetupNugetSources.sh
@@ -11,8 +11,8 @@
# - task: Bash@3
# displayName: Setup Internal Feeds
# inputs:
-# filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
-# arguments: $(Build.SourcesDirectory)/NuGet.config
+# filePath: $(System.DefaultWorkingDirectory)/eng/common/SetupNugetSources.sh
+# arguments: $(System.DefaultWorkingDirectory)/NuGet.config
# condition: ne(variables['Agent.OS'], 'Windows_NT')
# - task: NuGetAuthenticate@1
#
diff --git a/eng/common/core-templates/job/job.yml b/eng/common/core-templates/job/job.yml
index 6badecba7bcc4d..5ce51840619888 100644
--- a/eng/common/core-templates/job/job.yml
+++ b/eng/common/core-templates/job/job.yml
@@ -20,6 +20,7 @@ parameters:
artifacts: ''
enableMicrobuild: false
enableMicrobuildForMacAndLinux: false
+ microbuildUseESRP: true
enablePublishBuildArtifacts: false
enablePublishBuildAssets: false
enablePublishTestResults: false
@@ -128,6 +129,7 @@ jobs:
parameters:
enableMicrobuild: ${{ parameters.enableMicrobuild }}
enableMicrobuildForMacAndLinux: ${{ parameters.enableMicrobuildForMacAndLinux }}
+ microbuildUseESRP: ${{ parameters.microbuildUseESRP }}
continueOnError: ${{ parameters.continueOnError }}
- ${{ if and(eq(parameters.runAsPublic, 'false'), eq(variables['System.TeamProject'], 'internal')) }}:
@@ -161,7 +163,7 @@ jobs:
inputs:
testResultsFormat: 'xUnit'
testResultsFiles: '*.xml'
- searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+ searchFolder: '$(System.DefaultWorkingDirectory)/artifacts/TestResults/$(_BuildConfig)'
testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-xunit
mergeTestResults: ${{ parameters.mergeTestResults }}
continueOnError: true
@@ -172,7 +174,7 @@ jobs:
inputs:
testResultsFormat: 'VSTest'
testResultsFiles: '*.trx'
- searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+ searchFolder: '$(System.DefaultWorkingDirectory)/artifacts/TestResults/$(_BuildConfig)'
testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-trx
mergeTestResults: ${{ parameters.mergeTestResults }}
continueOnError: true
@@ -216,7 +218,7 @@ jobs:
- task: CopyFiles@2
displayName: Gather buildconfiguration for build retry
inputs:
- SourceFolder: '$(Build.SourcesDirectory)/eng/common/BuildConfiguration'
+ SourceFolder: '$(System.DefaultWorkingDirectory)/eng/common/BuildConfiguration'
Contents: '**'
TargetFolder: '$(Build.ArtifactStagingDirectory)/eng/common/BuildConfiguration'
continueOnError: true
diff --git a/eng/common/core-templates/job/onelocbuild.yml b/eng/common/core-templates/job/onelocbuild.yml
index 8034815f4213b1..c5788829a872e5 100644
--- a/eng/common/core-templates/job/onelocbuild.yml
+++ b/eng/common/core-templates/job/onelocbuild.yml
@@ -4,11 +4,11 @@ parameters:
# Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
pool: ''
-
+
CeapexPat: $(dn-bot-ceapex-package-r) # PAT for the loc AzDO instance https://dev.azure.com/ceapex
GithubPat: $(BotAccount-dotnet-bot-repo-PAT)
- SourcesDirectory: $(Build.SourcesDirectory)
+ SourcesDirectory: $(System.DefaultWorkingDirectory)
CreatePr: true
AutoCompletePr: false
ReusePr: true
@@ -27,7 +27,7 @@ parameters:
is1ESPipeline: ''
jobs:
- job: OneLocBuild${{ parameters.JobNameSuffix }}
-
+
dependsOn: ${{ parameters.dependsOn }}
displayName: OneLocBuild${{ parameters.JobNameSuffix }}
@@ -68,7 +68,7 @@ jobs:
- ${{ if ne(parameters.SkipLocProjectJsonGeneration, 'true') }}:
- task: Powershell@2
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/generate-locproject.ps1
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/generate-locproject.ps1
arguments: $(_GenerateLocProjectArguments)
displayName: Generate LocProject.json
condition: ${{ parameters.condition }}
@@ -99,22 +99,20 @@ jobs:
mirrorBranch: ${{ parameters.MirrorBranch }}
condition: ${{ parameters.condition }}
- - template: /eng/common/core-templates/steps/publish-build-artifacts.yml
- parameters:
- is1ESPipeline: ${{ parameters.is1ESPipeline }}
- args:
- displayName: Publish Localization Files
- pathToPublish: '$(Build.ArtifactStagingDirectory)/loc'
- publishLocation: Container
- artifactName: Loc
- condition: ${{ parameters.condition }}
+ # Copy the locProject.json to the root of the Loc directory, then publish a pipeline artifact
+ - task: CopyFiles@2
+ displayName: Copy LocProject.json
+ inputs:
+ SourceFolder: '$(System.DefaultWorkingDirectory)/eng/Localize/'
+ Contents: 'LocProject.json'
+ TargetFolder: '$(Build.ArtifactStagingDirectory)/loc'
+ condition: ${{ parameters.condition }}
- - template: /eng/common/core-templates/steps/publish-build-artifacts.yml
+ - template: /eng/common/core-templates/steps/publish-pipeline-artifacts.yml
parameters:
is1ESPipeline: ${{ parameters.is1ESPipeline }}
args:
- displayName: Publish LocProject.json
- pathToPublish: '$(Build.SourcesDirectory)/eng/Localize/'
- publishLocation: Container
- artifactName: Loc
+ targetPath: '$(Build.ArtifactStagingDirectory)/loc'
+ artifactName: 'Loc'
+ displayName: 'Publish Localization Files'
condition: ${{ parameters.condition }}
diff --git a/eng/common/core-templates/job/publish-build-assets.yml b/eng/common/core-templates/job/publish-build-assets.yml
index d5303229c97e27..348cd16376f10d 100644
--- a/eng/common/core-templates/job/publish-build-assets.yml
+++ b/eng/common/core-templates/job/publish-build-assets.yml
@@ -38,6 +38,8 @@ parameters:
# Optional: A minimatch pattern for the asset manifests to publish to BAR
assetManifestsPattern: '*/manifests/**/*.xml'
+ repositoryAlias: self
+
jobs:
- job: Asset_Registry_Publish
@@ -78,7 +80,7 @@ jobs:
- 'Illegal entry point, is1ESPipeline is not defined. Repository yaml should not directly reference templates in core-templates folder.': error
- ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
- - checkout: self
+ - checkout: ${{ parameters.repositoryAlias }}
fetchDepth: 3
clean: true
@@ -117,7 +119,7 @@ jobs:
azureSubscription: "Darc: Maestro Production"
scriptType: ps
scriptLocation: scriptPath
- scriptPath: $(Build.SourcesDirectory)/eng/common/sdk-task.ps1
+ scriptPath: $(System.DefaultWorkingDirectory)/eng/common/sdk-task.ps1
arguments: -task PublishBuildAssets -restore -msbuildEngine dotnet
/p:ManifestsPath='$(Build.StagingDirectory)/AssetManifests'
/p:IsAssetlessBuild=${{ parameters.isAssetlessBuild }}
@@ -137,7 +139,7 @@ jobs:
Add-Content -Path $filePath -Value "$(DefaultChannels)"
Add-Content -Path $filePath -Value $(IsStableBuild)
- $symbolExclusionfile = "$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt"
+ $symbolExclusionfile = "$(System.DefaultWorkingDirectory)/eng/SymbolPublishingExclusionsFile.txt"
if (Test-Path -Path $symbolExclusionfile)
{
Write-Host "SymbolExclusionFile exists"
@@ -177,7 +179,7 @@ jobs:
azureSubscription: "Darc: Maestro Production"
scriptType: ps
scriptLocation: scriptPath
- scriptPath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+ scriptPath: $(System.DefaultWorkingDirectory)/eng/common/post-build/publish-using-darc.ps1
arguments: >
-BuildId $(BARBuildId)
-PublishingInfraVersion 3
diff --git a/eng/common/core-templates/jobs/codeql-build.yml b/eng/common/core-templates/jobs/codeql-build.yml
index 693b00b370447b..dbc14ac580a271 100644
--- a/eng/common/core-templates/jobs/codeql-build.yml
+++ b/eng/common/core-templates/jobs/codeql-build.yml
@@ -24,7 +24,7 @@ jobs:
- name: DefaultGuardianVersion
value: 0.109.0
- name: GuardianPackagesConfigFile
- value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
+ value: $(System.DefaultWorkingDirectory)\eng\common\sdl\packages.config
- name: GuardianVersion
value: ${{ coalesce(parameters.overrideGuardianVersion, '$(DefaultGuardianVersion)') }}
diff --git a/eng/common/core-templates/jobs/jobs.yml b/eng/common/core-templates/jobs/jobs.yml
index bf35b78faa60e8..b637cb6e94808e 100644
--- a/eng/common/core-templates/jobs/jobs.yml
+++ b/eng/common/core-templates/jobs/jobs.yml
@@ -43,6 +43,7 @@ parameters:
artifacts: {}
is1ESPipeline: ''
+ repositoryAlias: self
# Internal resources (telemetry, microbuild) can only be accessed from non-public projects,
# and some (Microbuild) should only be applied to non-PR cases for internal builds.
@@ -83,7 +84,6 @@ jobs:
- template: /eng/common/core-templates/jobs/source-build.yml
parameters:
is1ESPipeline: ${{ parameters.is1ESPipeline }}
- allCompletedJobId: Source_Build_Complete
${{ each parameter in parameters.sourceBuildParameters }}:
${{ parameter.key }}: ${{ parameter.value }}
@@ -108,8 +108,6 @@ jobs:
- ${{ if eq(parameters.publishBuildAssetsDependsOn, '') }}:
- ${{ each job in parameters.jobs }}:
- ${{ job.job }}
- - ${{ if eq(parameters.enableSourceBuild, true) }}:
- - Source_Build_Complete
runAsPublic: ${{ parameters.runAsPublic }}
publishAssetsImmediately: ${{ or(parameters.publishAssetsImmediately, parameters.isAssetlessBuild) }}
@@ -117,3 +115,4 @@ jobs:
enablePublishBuildArtifacts: ${{ parameters.enablePublishBuildArtifacts }}
artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
signingValidationAdditionalParameters: ${{ parameters.signingValidationAdditionalParameters }}
+ repositoryAlias: ${{ parameters.repositoryAlias }}
diff --git a/eng/common/core-templates/jobs/source-build.yml b/eng/common/core-templates/jobs/source-build.yml
index df24c948ba1279..d92860cba20874 100644
--- a/eng/common/core-templates/jobs/source-build.yml
+++ b/eng/common/core-templates/jobs/source-build.yml
@@ -2,12 +2,6 @@ parameters:
# This template adds arcade-powered source-build to CI. A job is created for each platform, as
# well as an optional server job that completes when all platform jobs complete.
- # The name of the "join" job for all source-build platforms. If set to empty string, the job is
- # not included. Existing repo pipelines can use this job depend on all source-build jobs
- # completing without maintaining a separate list of every single job ID: just depend on this one
- # server job. By default, not included. Recommended name if used: 'Source_Build_Complete'.
- allCompletedJobId: ''
-
# See /eng/common/core-templates/job/source-build.yml
jobNamePrefix: 'Source_Build'
@@ -31,16 +25,6 @@ parameters:
jobs:
-- ${{ if ne(parameters.allCompletedJobId, '') }}:
- - job: ${{ parameters.allCompletedJobId }}
- displayName: Source-Build Complete
- pool: server
- dependsOn:
- - ${{ each platform in parameters.platforms }}:
- - ${{ parameters.jobNamePrefix }}_${{ platform.name }}
- - ${{ if eq(length(parameters.platforms), 0) }}:
- - ${{ parameters.jobNamePrefix }}_${{ parameters.defaultManagedPlatform.name }}
-
- ${{ each platform in parameters.platforms }}:
- template: /eng/common/core-templates/job/source-build.yml
parameters:
diff --git a/eng/common/core-templates/post-build/post-build.yml b/eng/common/core-templates/post-build/post-build.yml
index a151fd811e3e48..f6f87fe5c675d9 100644
--- a/eng/common/core-templates/post-build/post-build.yml
+++ b/eng/common/core-templates/post-build/post-build.yml
@@ -154,7 +154,7 @@ stages:
- task: PowerShell@2
displayName: Validate
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/post-build/nuget-validation.ps1
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/post-build/nuget-validation.ps1
arguments: -PackagesPath $(Build.ArtifactStagingDirectory)/PackageArtifacts/
- job:
@@ -208,7 +208,7 @@ stages:
filePath: eng\common\sdk-task.ps1
arguments: -task SigningValidation -restore -msbuildEngine vs
/p:PackageBasePath='$(Build.ArtifactStagingDirectory)/PackageArtifacts'
- /p:SignCheckExclusionsFile='$(Build.SourcesDirectory)/eng/SignCheckExclusionsFile.txt'
+ /p:SignCheckExclusionsFile='$(System.DefaultWorkingDirectory)/eng/SignCheckExclusionsFile.txt'
${{ parameters.signingValidationAdditionalParameters }}
- template: /eng/common/core-templates/steps/publish-logs.yml
@@ -258,7 +258,7 @@ stages:
- task: PowerShell@2
displayName: Validate
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/post-build/sourcelink-validation.ps1
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/post-build/sourcelink-validation.ps1
arguments: -InputPath $(Build.ArtifactStagingDirectory)/BlobArtifacts/
-ExtractPath $(Agent.BuildDirectory)/Extract/
-GHRepoName $(Build.Repository.Name)
@@ -313,7 +313,7 @@ stages:
azureSubscription: "Darc: Maestro Production"
scriptType: ps
scriptLocation: scriptPath
- scriptPath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+ scriptPath: $(System.DefaultWorkingDirectory)/eng/common/post-build/publish-using-darc.ps1
arguments: >
-BuildId $(BARBuildId)
-PublishingInfraVersion ${{ parameters.publishingInfraVersion }}
diff --git a/eng/common/core-templates/post-build/setup-maestro-vars.yml b/eng/common/core-templates/post-build/setup-maestro-vars.yml
index f7602980dbe721..a7abd58c4bb609 100644
--- a/eng/common/core-templates/post-build/setup-maestro-vars.yml
+++ b/eng/common/core-templates/post-build/setup-maestro-vars.yml
@@ -36,7 +36,7 @@ steps:
$AzureDevOpsBuildId = $Env:Build_BuildId
}
else {
- . $(Build.SourcesDirectory)\eng\common\tools.ps1
+ . $(System.DefaultWorkingDirectory)\eng\common\tools.ps1
$darc = Get-Darc
$buildInfo = & $darc get-build `
--id ${{ parameters.BARBuildId }} `
diff --git a/eng/common/core-templates/steps/enable-internal-sources.yml b/eng/common/core-templates/steps/enable-internal-sources.yml
index 64f881bffc3cf1..4085512b690910 100644
--- a/eng/common/core-templates/steps/enable-internal-sources.yml
+++ b/eng/common/core-templates/steps/enable-internal-sources.yml
@@ -17,8 +17,8 @@ steps:
- task: PowerShell@2
displayName: Setup Internal Feeds
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
- arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/SetupNugetSources.ps1
+ arguments: -ConfigFile $(System.DefaultWorkingDirectory)/NuGet.config -Password $Env:Token
env:
Token: ${{ parameters.legacyCredential }}
# If running on dnceng (internal project), just use the default behavior for NuGetAuthenticate.
@@ -29,8 +29,8 @@ steps:
- task: PowerShell@2
displayName: Setup Internal Feeds
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
- arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/SetupNugetSources.ps1
+ arguments: -ConfigFile $(System.DefaultWorkingDirectory)/NuGet.config
- ${{ else }}:
- template: /eng/common/templates/steps/get-federated-access-token.yml
parameters:
@@ -39,8 +39,8 @@ steps:
- task: PowerShell@2
displayName: Setup Internal Feeds
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
- arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $(dnceng-artifacts-feeds-read-access-token)
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/SetupNugetSources.ps1
+ arguments: -ConfigFile $(System.DefaultWorkingDirectory)/NuGet.config -Password $(dnceng-artifacts-feeds-read-access-token)
# This is required in certain scenarios to install the ADO credential provider.
# It installed by default in some msbuild invocations (e.g. VS msbuild), but needs to be installed for others
# (e.g. dotnet msbuild).
diff --git a/eng/common/core-templates/steps/generate-sbom.yml b/eng/common/core-templates/steps/generate-sbom.yml
index 44a9636cdff90a..c05f650279795f 100644
--- a/eng/common/core-templates/steps/generate-sbom.yml
+++ b/eng/common/core-templates/steps/generate-sbom.yml
@@ -6,7 +6,7 @@
parameters:
PackageVersion: 10.0.0
- BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+ BuildDropPath: '$(System.DefaultWorkingDirectory)/artifacts'
PackageName: '.NET'
ManifestDirPath: $(Build.ArtifactStagingDirectory)/sbom
IgnoreDirectories: ''
diff --git a/eng/common/core-templates/steps/install-microbuild.yml b/eng/common/core-templates/steps/install-microbuild.yml
index f3064a7834edca..d6b9878f54db7f 100644
--- a/eng/common/core-templates/steps/install-microbuild.yml
+++ b/eng/common/core-templates/steps/install-microbuild.yml
@@ -4,8 +4,17 @@ parameters:
# Enable install tasks for MicroBuild on Mac and Linux
# Will be ignored if 'enableMicrobuild' is false or 'Agent.Os' is 'Windows_NT'
enableMicrobuildForMacAndLinux: false
+ # Determines whether the ESRP service connection information should be passed to the signing plugin.
+ # This overlaps with _SignType to some degree. We only need the service connection for real signing.
+ # It's important that the service connection not be passed to the MicroBuildSigningPlugin task in this place.
+ # Doing so will cause the service connection to be authorized for the pipeline, which isn't allowed and won't work for non-prod.
+ # Unfortunately, _SignType can't be used to exclude the use of the service connection in non-real sign scenarios. The
+ # variable is not available in template expression. _SignType has a very large proliferation across .NET, so replacing it is tough.
+ microbuildUseESRP: true
# Location of the MicroBuild output folder
+ # NOTE: There's something that relies on this being in the "default" source directory for tasks such as Signing to work properly.
microBuildOutputFolder: '$(Build.SourcesDirectory)'
+
continueOnError: false
steps:
@@ -21,34 +30,62 @@ steps:
workingDirectory: ${{ parameters.microBuildOutputFolder }}
condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT'))
+ - script: |
+ REM Check if ESRP is disabled while SignType is real
+ if /I "${{ parameters.microbuildUseESRP }}"=="false" if /I "$(_SignType)"=="real" (
+ echo Error: ESRP must be enabled when SignType is real.
+ exit /b 1
+ )
+ displayName: 'Validate ESRP usage (Windows)'
+ condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT'))
+ - script: |
+ # Check if ESRP is disabled while SignType is real
+ if [ "${{ parameters.microbuildUseESRP }}" = "false" ] && [ "$(_SignType)" = "real" ]; then
+ echo "Error: ESRP must be enabled when SignType is real."
+ exit 1
+ fi
+ displayName: 'Validate ESRP usage (Non-Windows)'
+ condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT'))
+
+ # Two different MB install steps. This is due to not being able to use the agent OS during
+ # YAML expansion, and Windows vs. Linux/Mac uses different service connections. However,
+ # we can avoid including the MB install step if not enabled at all. This avoids a bunch of
+ # extra pipeline authorizations, since most pipelines do not sign on non-Windows.
- task: MicroBuildSigningPlugin@4
- displayName: Install MicroBuild plugin
+ displayName: Install MicroBuild plugin (Windows)
inputs:
signType: $(_SignType)
zipSources: false
feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
- ${{ if and(eq(parameters.enableMicrobuildForMacAndLinux, 'true'), ne(variables['Agent.Os'], 'Windows_NT')) }}:
- azureSubscription: 'MicroBuild Signing Task (DevDiv)'
- useEsrpCli: true
- ${{ elseif eq(variables['System.TeamProject'], 'DevDiv') }}:
- ConnectedPMEServiceName: 6cc74545-d7b9-4050-9dfa-ebefcc8961ea
- ${{ else }}:
- ConnectedPMEServiceName: 248d384a-b39b-46e3-8ad5-c2c210d5e7ca
+ ${{ if eq(parameters.microbuildUseESRP, true) }}:
+ ConnectedServiceName: 'MicroBuild Signing Task (DevDiv)'
+ ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+ ConnectedPMEServiceName: 6cc74545-d7b9-4050-9dfa-ebefcc8961ea
+ ${{ else }}:
+ ConnectedPMEServiceName: 248d384a-b39b-46e3-8ad5-c2c210d5e7ca
env:
TeamName: $(_TeamName)
MicroBuildOutputFolderOverride: ${{ parameters.microBuildOutputFolder }}
SYSTEM_ACCESSTOKEN: $(System.AccessToken)
continueOnError: ${{ parameters.continueOnError }}
- condition: and(
- succeeded(),
- or(
- and(
- eq(variables['Agent.Os'], 'Windows_NT'),
- in(variables['_SignType'], 'real', 'test')
- ),
- and(
- ${{ eq(parameters.enableMicrobuildForMacAndLinux, true) }},
- ne(variables['Agent.Os'], 'Windows_NT'),
- eq(variables['_SignType'], 'real')
- )
- ))
+ condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT'), in(variables['_SignType'], 'real', 'test'))
+
+ - ${{ if eq(parameters.enableMicrobuildForMacAndLinux, true) }}:
+ - task: MicroBuildSigningPlugin@4
+ displayName: Install MicroBuild plugin (non-Windows)
+ inputs:
+ signType: $(_SignType)
+ zipSources: false
+ feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
+ ${{ if eq(parameters.microbuildUseESRP, true) }}:
+ ConnectedServiceName: 'MicroBuild Signing Task (DevDiv)'
+ ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+ ConnectedPMEServiceName: beb8cb23-b303-4c95-ab26-9e44bc958d39
+ ${{ else }}:
+ ConnectedPMEServiceName: c24de2a5-cc7a-493d-95e4-8e5ff5cad2bc
+ env:
+ TeamName: $(_TeamName)
+ MicroBuildOutputFolderOverride: ${{ parameters.microBuildOutputFolder }}
+ SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+ continueOnError: ${{ parameters.continueOnError }}
+ condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT'), eq(variables['_SignType'], 'real'))
diff --git a/eng/common/core-templates/steps/publish-logs.yml b/eng/common/core-templates/steps/publish-logs.yml
index de24d0087c58bb..10f825e270a03b 100644
--- a/eng/common/core-templates/steps/publish-logs.yml
+++ b/eng/common/core-templates/steps/publish-logs.yml
@@ -12,22 +12,22 @@ steps:
inputs:
targetType: inline
script: |
- New-Item -ItemType Directory $(Build.SourcesDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
- Move-Item -Path $(Build.SourcesDirectory)/artifacts/log/Debug/* $(Build.SourcesDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
+ New-Item -ItemType Directory $(System.DefaultWorkingDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
+ Move-Item -Path $(System.DefaultWorkingDirectory)/artifacts/log/Debug/* $(System.DefaultWorkingDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
continueOnError: true
condition: always()
- task: PowerShell@2
displayName: Redact Logs
inputs:
- filePath: $(Build.SourcesDirectory)/eng/common/post-build/redact-logs.ps1
+ filePath: $(System.DefaultWorkingDirectory)/eng/common/post-build/redact-logs.ps1
# For now this needs to have explicit list of all sensitive data. Taken from eng/publishing/v3/publish.yml
- # Sensitive data can as well be added to $(Build.SourcesDirectory)/eng/BinlogSecretsRedactionFile.txt'
+ # Sensitive data can as well be added to $(System.DefaultWorkingDirectory)/eng/BinlogSecretsRedactionFile.txt'
# If the file exists - sensitive data for redaction will be sourced from it
# (single entry per line, lines starting with '# ' are considered comments and skipped)
- arguments: -InputPath '$(Build.SourcesDirectory)/PostBuildLogs'
+ arguments: -InputPath '$(System.DefaultWorkingDirectory)/PostBuildLogs'
-BinlogToolVersion ${{parameters.BinlogToolVersion}}
- -TokensFilePath '$(Build.SourcesDirectory)/eng/BinlogSecretsRedactionFile.txt'
+ -TokensFilePath '$(System.DefaultWorkingDirectory)/eng/BinlogSecretsRedactionFile.txt'
'$(publishing-dnceng-devdiv-code-r-build-re)'
'$(MaestroAccessToken)'
'$(dn-bot-all-orgs-artifact-feeds-rw)'
@@ -44,7 +44,7 @@ steps:
- task: CopyFiles@2
displayName: Gather post build logs
inputs:
- SourceFolder: '$(Build.SourcesDirectory)/PostBuildLogs'
+ SourceFolder: '$(System.DefaultWorkingDirectory)/PostBuildLogs'
Contents: '**'
TargetFolder: '$(Build.ArtifactStagingDirectory)/PostBuildLogs'
condition: always()
diff --git a/eng/common/core-templates/steps/source-index-stage1-publish.yml b/eng/common/core-templates/steps/source-index-stage1-publish.yml
index c2917c1efc1cb7..75600735f175e6 100644
--- a/eng/common/core-templates/steps/source-index-stage1-publish.yml
+++ b/eng/common/core-templates/steps/source-index-stage1-publish.yml
@@ -20,7 +20,7 @@ steps:
# Set working directory to temp directory so 'dotnet' doesn't try to use global.json and use the repo's sdk.
workingDirectory: $(Agent.TempDirectory)
-- script: $(Agent.TempDirectory)/.source-index/tools/BinLogToSln -i ${{parameters.BinlogPath}} -r $(Build.SourcesDirectory) -n $(Build.Repository.Name) -o .source-index/stage1output
+- script: $(Agent.TempDirectory)/.source-index/tools/BinLogToSln -i ${{parameters.BinlogPath}} -r $(System.DefaultWorkingDirectory) -n $(Build.Repository.Name) -o .source-index/stage1output
displayName: "Source Index: Process Binlog into indexable sln"
- ${{ if and(ne(parameters.runAsPublic, 'true'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
diff --git a/eng/common/generate-locproject.ps1 b/eng/common/generate-locproject.ps1
index 524aaa57f2b742..fa1cdc2b30076a 100644
--- a/eng/common/generate-locproject.ps1
+++ b/eng/common/generate-locproject.ps1
@@ -33,15 +33,27 @@ $jsonTemplateFiles | ForEach-Object {
$jsonWinformsTemplateFiles = Get-ChildItem -Recurse -Path "$SourcesDirectory" | Where-Object { $_.FullName -Match "en\\strings\.json" } # current winforms pattern
+$wxlFilesV3 = @()
+$wxlFilesV5 = @()
$wxlFiles = Get-ChildItem -Recurse -Path "$SourcesDirectory" | Where-Object { $_.FullName -Match "\\.+\.wxl" -And -Not( $_.Directory.Name -Match "\d{4}" ) } # localized files live in four digit lang ID directories; this excludes them
if (-not $wxlFiles) {
$wxlEnFiles = Get-ChildItem -Recurse -Path "$SourcesDirectory" | Where-Object { $_.FullName -Match "\\1033\\.+\.wxl" } # pick up en files (1033 = en) specifically so we can copy them to use as the neutral xlf files
if ($wxlEnFiles) {
- $wxlFiles = @()
- $wxlEnFiles | ForEach-Object {
- $destinationFile = "$($_.Directory.Parent.FullName)\$($_.Name)"
- $wxlFiles += Copy-Item "$($_.FullName)" -Destination $destinationFile -PassThru
- }
+ $wxlFiles = @()
+ $wxlEnFiles | ForEach-Object {
+ $destinationFile = "$($_.Directory.Parent.FullName)\$($_.Name)"
+ $content = Get-Content $_.FullName -Raw
+
+ # Split files on schema to select different parser settings in the generated project.
+ if ($content -like "*http://wixtoolset.org/schemas/v4/wxl*")
+ {
+ $wxlFilesV5 += Copy-Item $_.FullName -Destination $destinationFile -PassThru
+ }
+ elseif ($content -like "*http://schemas.microsoft.com/wix/2006/localization*")
+ {
+ $wxlFilesV3 += Copy-Item $_.FullName -Destination $destinationFile -PassThru
+ }
+ }
}
}
@@ -114,7 +126,32 @@ $locJson = @{
CloneLanguageSet = "WiX_CloneLanguages"
LssFiles = @( "wxl_loc.lss" )
LocItems = @(
- $wxlFiles | ForEach-Object {
+ $wxlFilesV3 | ForEach-Object {
+ $outputPath = "$($_.Directory.FullName | Resolve-Path -Relative)\"
+ $continue = $true
+ foreach ($exclusion in $exclusions.Exclusions) {
+ if ($_.FullName.Contains($exclusion)) {
+ $continue = $false
+ }
+ }
+ $sourceFile = ($_.FullName | Resolve-Path -Relative)
+ if ($continue)
+ {
+ return @{
+ SourceFile = $sourceFile
+ CopyOption = "LangIDOnPath"
+ OutputPath = $outputPath
+ }
+ }
+ }
+ )
+ },
+ @{
+ LanguageSet = $LanguageSet
+ CloneLanguageSet = "WiX_CloneLanguages"
+ LssFiles = @( "P210WxlSchemaV4.lss" )
+ LocItems = @(
+ $wxlFilesV5 | ForEach-Object {
$outputPath = "$($_.Directory.FullName | Resolve-Path -Relative)\"
$continue = $true
foreach ($exclusion in $exclusions.Exclusions) {
diff --git a/eng/common/template-guidance.md b/eng/common/template-guidance.md
index 98bbc1ded0ba88..4bf4cf41bd7c76 100644
--- a/eng/common/template-guidance.md
+++ b/eng/common/template-guidance.md
@@ -50,7 +50,7 @@ extends:
- task: CopyFiles@2
displayName: Gather build output
inputs:
- SourceFolder: '$(Build.SourcesDirectory)/artifacts/marvel'
+ SourceFolder: '$(System.DefaultWorkingDirectory)/artifacts/marvel'
Contents: '**'
TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/marvel'
```
diff --git a/eng/common/templates-official/job/job.yml b/eng/common/templates-official/job/job.yml
index a8a94328745823..92a0664f5647d5 100644
--- a/eng/common/templates-official/job/job.yml
+++ b/eng/common/templates-official/job/job.yml
@@ -3,7 +3,7 @@ parameters:
enableSbom: true
runAsPublic: false
PackageVersion: 9.0.0
- BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+ BuildDropPath: '$(System.DefaultWorkingDirectory)/artifacts'
jobs:
- template: /eng/common/core-templates/job/job.yml
diff --git a/eng/common/templates-official/variables/sdl-variables.yml b/eng/common/templates-official/variables/sdl-variables.yml
index dbdd66d4a4b3a0..f1311bbb1b33d9 100644
--- a/eng/common/templates-official/variables/sdl-variables.yml
+++ b/eng/common/templates-official/variables/sdl-variables.yml
@@ -4,4 +4,4 @@ variables:
- name: DefaultGuardianVersion
value: 0.109.0
- name: GuardianPackagesConfigFile
- value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
\ No newline at end of file
+ value: $(System.DefaultWorkingDirectory)\eng\common\sdl\packages.config
\ No newline at end of file
diff --git a/eng/common/templates/job/job.yml b/eng/common/templates/job/job.yml
index 7cbf668c22bc04..238fa0818f7b27 100644
--- a/eng/common/templates/job/job.yml
+++ b/eng/common/templates/job/job.yml
@@ -6,7 +6,7 @@ parameters:
enableSbom: true
runAsPublic: false
PackageVersion: 9.0.0
- BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+ BuildDropPath: '$(System.DefaultWorkingDirectory)/artifacts'
jobs:
- template: /eng/common/core-templates/job/job.yml
@@ -77,7 +77,7 @@ jobs:
parameters:
is1ESPipeline: false
args:
- targetPath: '$(Build.SourcesDirectory)\eng\common\BuildConfiguration'
+ targetPath: '$(System.DefaultWorkingDirectory)\eng\common\BuildConfiguration'
artifactName: 'BuildConfiguration'
displayName: 'Publish build retry configuration'
continueOnError: true
diff --git a/eng/common/tools.ps1 b/eng/common/tools.ps1
index 40f0aa86128e48..4920464cc4ae3e 100644
--- a/eng/common/tools.ps1
+++ b/eng/common/tools.ps1
@@ -257,7 +257,20 @@ function Retry($downloadBlock, $maxRetries = 5) {
function GetDotNetInstallScript([string] $dotnetRoot) {
$installScript = Join-Path $dotnetRoot 'dotnet-install.ps1'
+ $shouldDownload = $false
+
if (!(Test-Path $installScript)) {
+ $shouldDownload = $true
+ } else {
+ # Check if the script is older than 30 days
+ $fileAge = (Get-Date) - (Get-Item $installScript).LastWriteTime
+ if ($fileAge.Days -gt 30) {
+ Write-Host "Existing install script is too old, re-downloading..."
+ $shouldDownload = $true
+ }
+ }
+
+ if ($shouldDownload) {
Create-Directory $dotnetRoot
$ProgressPreference = 'SilentlyContinue' # Don't display the console progress UI - it's a huge perf hit
$uri = "https://builds.dotnet.microsoft.com/dotnet/scripts/$dotnetInstallScriptVersion/dotnet-install.ps1"
@@ -414,7 +427,7 @@ function InitializeVisualStudioMSBuild([bool]$install, [object]$vsRequirements =
# Locate Visual Studio installation or download x-copy msbuild.
$vsInfo = LocateVisualStudio $vsRequirements
- if ($vsInfo -ne $null) {
+ if ($vsInfo -ne $null -and $env:ForceUseXCopyMSBuild -eq $null) {
# Ensure vsInstallDir has a trailing slash
$vsInstallDir = Join-Path $vsInfo.installationPath "\"
$vsMajorVersion = $vsInfo.installationVersion.Split('.')[0]
@@ -531,7 +544,8 @@ function LocateVisualStudio([object]$vsRequirements = $null){
if (Get-Member -InputObject $GlobalJson.tools -Name 'vswhere') {
$vswhereVersion = $GlobalJson.tools.vswhere
} else {
- $vswhereVersion = '2.5.2'
+ # keep this in sync with the VSWhereVersion in DefaultVersions.props
+ $vswhereVersion = '3.1.7'
}
$vsWhereDir = Join-Path $ToolsDir "vswhere\$vswhereVersion"
@@ -539,7 +553,8 @@ function LocateVisualStudio([object]$vsRequirements = $null){
if (!(Test-Path $vsWhereExe)) {
Create-Directory $vsWhereDir
- Write-Host 'Downloading vswhere'
+ Write-Host 'Downloading vswhere $vswhereVersion'
+ $ProgressPreference = 'SilentlyContinue' # Don't display the console progress UI - it's a huge perf hit
Retry({
Invoke-WebRequest "https://netcorenativeassets.blob.core.windows.net/resource-packages/external/windows/vswhere/$vswhereVersion/vswhere.exe" -OutFile $vswhereExe
})
diff --git a/eng/common/tools.sh b/eng/common/tools.sh
index 3def02a638d2e8..c1841c9dfd0f4e 100755
--- a/eng/common/tools.sh
+++ b/eng/common/tools.sh
@@ -300,8 +300,29 @@ function GetDotNetInstallScript {
local root=$1
local install_script="$root/dotnet-install.sh"
local install_script_url="https://builds.dotnet.microsoft.com/dotnet/scripts/$dotnetInstallScriptVersion/dotnet-install.sh"
+ local timestamp_file="$root/.dotnet-install.timestamp"
+ local should_download=false
if [[ ! -a "$install_script" ]]; then
+ should_download=true
+ elif [[ -f "$timestamp_file" ]]; then
+ # Check if the script is older than 30 days using timestamp file
+ local download_time=$(cat "$timestamp_file" 2>/dev/null || echo "0")
+ local current_time=$(date +%s)
+ local age_seconds=$((current_time - download_time))
+
+ # 30 days = 30 * 24 * 60 * 60 = 2592000 seconds
+ if [[ $age_seconds -gt 2592000 ]]; then
+ echo "Existing install script is too old, re-downloading..."
+ should_download=true
+ fi
+ else
+ # No timestamp file exists, assume script is old and re-download
+ echo "No timestamp found for existing install script, re-downloading..."
+ should_download=true
+ fi
+
+ if [[ "$should_download" == true ]]; then
mkdir -p "$root"
echo "Downloading '$install_script_url'"
@@ -328,6 +349,9 @@ function GetDotNetInstallScript {
ExitWithExitCode $exit_code
}
fi
+
+ # Create timestamp file to track download time in seconds from epoch
+ date +%s > "$timestamp_file"
fi
# return value
_GetDotNetInstallScript="$install_script"
diff --git a/eng/generators.targets b/eng/generators.targets
index e4c4336b21edb5..1a25554a78f1b5 100644
--- a/eng/generators.targets
+++ b/eng/generators.targets
@@ -25,7 +25,7 @@
(
'$(DisableImplicitFrameworkReferences)' == 'true' and
(
- '@(Reference->AnyHaveMetadataValue('Identity', 'System.Runtime.InteropServices'))' == 'true' or
+ '@(ProjectReference->AnyHaveMetadataValue('Filename', 'System.Runtime.InteropServices'))' == 'true' or
'@(ProjectReference->AnyHaveMetadataValue('Identity', '$(CoreLibProject)'))' == 'true'
)
)" />
@@ -38,7 +38,7 @@
'$(MSBuildProjectExtension)' == '.csproj' and
(
'$(DisableImplicitFrameworkReferences)' == 'true' and
- '@(Reference->AnyHaveMetadataValue('Identity', 'System.Runtime.InteropServices'))' == 'true'
+ '@(ProjectReference->AnyHaveMetadataValue('Filename', 'System.Runtime.InteropServices'))' == 'true'
)" />
@@ -49,7 +49,7 @@
+ That is required as the EnabledGenerators condition checks on the ProjectReference items and hence can't be a property condition. -->
DESTINATION ${destination} COMPONENT ${INSTALL_CLR_COMPONENT})
+ install(PROGRAMS $ DESTINATION ${destination} COMPONENT ${INSTALL_CLR_COMPONENT} ${INSTALL_CLR_OPTIONAL})
if (NOT "${symbolFile}" STREQUAL "")
- install_symbol_file(${symbolFile} ${destination} COMPONENT ${INSTALL_CLR_COMPONENT})
+ install_symbol_file(${symbolFile} ${destination} COMPONENT ${INSTALL_CLR_COMPONENT} ${INSTALL_CLR_OPTIONAL})
endif()
if(CLR_CMAKE_PGO_INSTRUMENT)
diff --git a/eng/native/gen-buildsys.cmd b/eng/native/gen-buildsys.cmd
index 3a6e1b5426d65f..4a6bd162063682 100644
--- a/eng/native/gen-buildsys.cmd
+++ b/eng/native/gen-buildsys.cmd
@@ -45,19 +45,11 @@ if /i "%__Arch%" == "wasm" (
)
if /i "%__Os%" == "browser" (
if "%EMSDK_PATH%" == "" (
- if not exist "%__repoRoot%\src\mono\browser\emsdk" (
- echo Error: Should set EMSDK_PATH environment variable pointing to emsdk root.
- exit /B 1
- )
-
- set "EMSDK_PATH=%__repoRoot%\src\mono\browser\emsdk"
+ echo Error: Should set EMSDK_PATH environment variable pointing to emsdk root.
+ exit /B 1
)
- :: replace backslash with forward slash and append last slash
- set "EMSDK_PATH=!EMSDK_PATH:\=/!"
- if not "!EMSDK_PATH:~-1!" == "/" set "EMSDK_PATH=!EMSDK_PATH!/"
- set __ExtraCmakeParams=%__ExtraCmakeParams% "-DCMAKE_TOOLCHAIN_FILE=!EMSDK_PATH!/emscripten/cmake/Modules/Platform/Emscripten.cmake"
- set __UseEmcmake=1
+ set CMakeToolPrefix=emcmake
)
if /i "%__Os%" == "wasi" (
set "__repoRoot=!__repoRoot:\=/!"
@@ -135,12 +127,8 @@ if not "%__ConfigureOnly%" == "1" (
)
)
-if /i "%__UseEmcmake%" == "1" (
- call "!EMSDK_PATH!/emsdk_env.cmd" > nul 2>&1 && emcmake "%CMakePath%" %__ExtraCmakeParams% --no-warn-unused-cli -G "%__CmakeGenerator%" -B %__IntermediatesDir% -S %__SourceDir%
-) else (
- echo "%CMakePath% %__ExtraCmakeParams% --no-warn-unused-cli -G %__CmakeGenerator% -B %__IntermediatesDir% -S %__SourceDir%"
- "%CMakePath%" %__ExtraCmakeParams% --no-warn-unused-cli -G "%__CmakeGenerator%" -B %__IntermediatesDir% -S %__SourceDir%
-)
+echo %CMakeToolPrefix% "%CMakePath% %__ExtraCmakeParams% --no-warn-unused-cli -G %__CmakeGenerator% -B %__IntermediatesDir% -S %__SourceDir%"
+%CMakeToolPrefix% "%CMakePath%" %__ExtraCmakeParams% --no-warn-unused-cli -G "%__CmakeGenerator%" -B %__IntermediatesDir% -S %__SourceDir%
if "%errorlevel%" == "0" (
echo %__ExtraCmakeParams% > %__CmdLineOptionsUpToDateFile%
diff --git a/eng/pipelines/coreclr/interpreter.yml b/eng/pipelines/coreclr/interpreter.yml
index 746508b7372530..6392f36750f434 100644
--- a/eng/pipelines/coreclr/interpreter.yml
+++ b/eng/pipelines/coreclr/interpreter.yml
@@ -1,5 +1,13 @@
trigger: none
+schedules:
+- cron: "0 13 * * 1,3,5"
+ displayName: Every Monday, Wednesday and Friday at 5:00 AM (UTC-8:00)
+ branches:
+ include:
+ - main
+ always: true
+
variables:
- template: /eng/pipelines/common/variables.yml
diff --git a/eng/pipelines/coreclr/superpmi-diffs.yml b/eng/pipelines/coreclr/superpmi-diffs.yml
index 10ba7a7a1df002..5e8b4f12b31da6 100644
--- a/eng/pipelines/coreclr/superpmi-diffs.yml
+++ b/eng/pipelines/coreclr/superpmi-diffs.yml
@@ -55,8 +55,11 @@ extends:
platforms:
- osx_arm64
- windows_x86
+ # Not needed for subsequent steps, but this ensures we get some build
+ # coverage of community JITs in CI on JIT PRs.
+ - windows_x64
jobParameters:
- buildArgs: -s clr.alljits+clr.spmi -c $(_BuildConfig)
+ buildArgs: -s clr.alljitscommunity+clr.spmi -c $(_BuildConfig)
postBuildSteps:
# Build CLR assets for x64 as well as the target as we need an x64 mcs
- template: /eng/pipelines/common/templates/global-build-step.yml
diff --git a/eng/pipelines/coreclr/templates/jit-replay-pipeline.yml b/eng/pipelines/coreclr/templates/jit-replay-pipeline.yml
index 3ee415cb881a73..74f2caf2ff3852 100644
--- a/eng/pipelines/coreclr/templates/jit-replay-pipeline.yml
+++ b/eng/pipelines/coreclr/templates/jit-replay-pipeline.yml
@@ -32,7 +32,7 @@ extends:
buildConfig: checked
platforms: ${{ parameters.platforms }}
jobParameters:
- buildArgs: -s clr.alljitscommunity+clr.spmi -c $(_BuildConfig)
+ buildArgs: -s clr.alljits+clr.spmi -c $(_BuildConfig)
postBuildSteps:
- template: /eng/pipelines/common/upload-artifact-step.yml
parameters:
diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-android.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-android.yml
index 417241706c4c91..3a01170b624758 100644
--- a/eng/pipelines/extra-platforms/runtime-extra-platforms-android.yml
+++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-android.yml
@@ -76,7 +76,7 @@ jobs:
nameSuffix: AllSubsets_Mono
isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAdditionalTimezoneChecks=true
- timeoutInMinutes: 480
+ timeoutInMinutes: 240
# extra steps, run tests
postBuildSteps:
- template: /eng/pipelines/libraries/helix.yml
@@ -107,10 +107,41 @@ jobs:
nameSuffix: AllSubsets_CoreCLR
isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
buildArgs: -s clr.runtime+clr.alljits+clr.corelib+clr.nativecorelib+clr.tools+clr.packages+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg)
- timeoutInMinutes: 480
+ timeoutInMinutes: 240
# extra steps, run tests
postBuildSteps:
- template: /eng/pipelines/libraries/helix.yml
parameters:
creator: dotnet-bot
testRunNamePrefixSuffix: CoreCLR_$(_BuildConfig)
+
+#
+# Android arm64 devices and x64 emulators
+# Build the whole product using NativeAOT and run functional tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/common/global-build-job.yml
+ helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+ buildConfig: Release
+ runtimeFlavor: coreclr
+ platforms:
+ - android_arm64
+ variables:
+ # map dependencies variables to local variables
+ - name: librariesContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+ - name: coreclrContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'] ]
+ jobParameters:
+ testGroup: innerloop
+ nameSuffix: NativeAOT
+ isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
+ buildArgs: -s clr.aot+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:UseNativeAOTRuntime=true /p:RuntimeFlavor=coreclr /p:TestNativeAOT=true
+ timeoutInMinutes: 120
+ # extra steps, run tests
+ postBuildSteps:
+ - template: /eng/pipelines/libraries/helix.yml
+ parameters:
+ creator: dotnet-bot
+ testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-androidemulator.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-androidemulator.yml
index b7b3774f0b5a35..4f0c526aff1d38 100644
--- a/eng/pipelines/extra-platforms/runtime-extra-platforms-androidemulator.yml
+++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-androidemulator.yml
@@ -111,7 +111,7 @@ jobs:
nameSuffix: AllSubsets_Mono
isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg)
- timeoutInMinutes: 180
+ timeoutInMinutes: 240
# extra steps, run tests
postBuildSteps:
- template: /eng/pipelines/libraries/helix.yml
@@ -149,3 +149,36 @@ jobs:
parameters:
creator: dotnet-bot
testRunNamePrefixSuffix: CoreCLR_$(_BuildConfig)
+
+#
+# Android arm64 devices and x64 emulators
+# Build the whole product using NativeAOT and run functional tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/common/global-build-job.yml
+ helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+ buildConfig: Release
+ runtimeFlavor: coreclr
+ isExtraPlatformsBuild: ${{ parameters.isExtraPlatformsBuild }}
+ isAndroidEmulatorOnlyBuild: ${{ parameters.isAndroidEmulatorOnlyBuild }}
+ platforms:
+ - android_x64
+ variables:
+ # map dependencies variables to local variables
+ - name: librariesContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+ - name: coreclrContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'] ]
+ jobParameters:
+ testGroup: innerloop
+ nameSuffix: NativeAOT
+ isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
+ buildArgs: -s clr.aot+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:UseNativeAOTRuntime=true /p:RuntimeFlavor=coreclr /p:TestNativeAOT=true
+ timeoutInMinutes: 120
+ # extra steps, run tests
+ postBuildSteps:
+ - template: /eng/pipelines/libraries/helix.yml
+ parameters:
+ creator: dotnet-bot
+ testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml
index 7f10d317464cf8..82726e28094227 100644
--- a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml
+++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml
@@ -42,7 +42,7 @@ jobs:
buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=true $(_runSmokeTestsOnlyArg) /p:BuildTestsOnHelix=true /p:EnableAdditionalTimezoneChecks=true /p:UsePortableRuntimePack=false /p:IsManualOrRollingBuild=true /p:EnableAggressiveTrimming=false
${{ else }}:
buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=true $(_runSmokeTestsOnlyArg) /p:BuildTestsOnHelix=true /p:EnableAdditionalTimezoneChecks=true /p:UsePortableRuntimePack=false /p:IsManualOrRollingBuild=true /p:EnableAggressiveTrimming=true
- timeoutInMinutes: 480
+ timeoutInMinutes: 240
# extra steps, run tests
postBuildSteps:
- template: /eng/pipelines/libraries/helix.yml
@@ -81,7 +81,7 @@ jobs:
testGroup: innerloop
nameSuffix: AllSubsets_Mono_RuntimeTests
buildArgs: -s mono+libs -c $(_BuildConfig)
- timeoutInMinutes: 480
+ timeoutInMinutes: 240
# extra steps, run tests
extraVariablesTemplates:
- template: /eng/pipelines/common/templates/runtimes/test-variables.yml
@@ -152,7 +152,7 @@ jobs:
jobParameters:
testGroup: innerloop
nameSuffix: AllSubsets_NativeAOT_RuntimeTests
- timeoutInMinutes: 480
+ timeoutInMinutes: 240
buildArgs: --cross -s clr.alljits+clr.tools+clr.nativeaotruntime+clr.nativeaotlibs+libs -c $(_BuildConfig)
# extra steps, run tests
extraVariablesTemplates:
diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml
index 9f483dbbe75eb3..80f29f2d8567eb 100644
--- a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml
+++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml
@@ -36,7 +36,7 @@ jobs:
testGroup: innerloop
nameSuffix: AllSubsets_Mono
buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:RunAOTCompilation=true /p:MonoForceInterpreter=true
- timeoutInMinutes: 180
+ timeoutInMinutes: 240
# extra steps, run tests
postBuildSteps:
- template: /eng/pipelines/libraries/helix.yml
@@ -119,7 +119,7 @@ jobs:
jobParameters:
testGroup: innerloop
nameSuffix: AllSubsets_NativeAOT_RuntimeTests
- timeoutInMinutes: 240
+ timeoutInMinutes: 180
buildArgs: --cross -s clr.alljits+clr.tools+clr.nativeaotruntime+clr.nativeaotlibs+libs -c $(_BuildConfig)
# extra steps, run tests
extraVariablesTemplates:
@@ -133,3 +133,37 @@ jobs:
testBuildArgs: tree nativeaot/SmokeTests /p:BuildNativeAOTRuntimePack=true
testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
buildAllTestsAsStandalone: true
+
+#
+# iOS simulator
+# Build the whole product using CoreCLR and run functional tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/common/global-build-job.yml
+ helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+ buildConfig: checked
+ runtimeFlavor: coreclr
+ isExtraPlatformsBuild: ${{ parameters.isExtraPlatformsBuild }}
+ isiOSLikeSimulatorOnlyBuild: ${{ parameters.isiOSLikeSimulatorOnlyBuild }}
+ platforms:
+ - iossimulator_arm64
+ variables:
+ # map dependencies variables to local variables
+ - name: librariesContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+ - name: coreclrContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'] ]
+ - name: illinkContainsChange
+ value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'] ]
+ jobParameters:
+ testGroup: innerloop
+ nameSuffix: AllSubsets_CoreCLR
+ buildArgs: -s clr+clr.runtime+libs+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=false /p:UseMonoRuntime=false /p:MonoForceInterpreter=false /p:RunSmokeTestsOnly=true
+ timeoutInMinutes: 120
+ # extra steps, run tests
+ postBuildSteps:
+ - template: /eng/pipelines/libraries/helix.yml
+ parameters:
+ creator: dotnet-bot
+ testRunNamePrefixSuffix: CoreCLR_$(_BuildConfig)
diff --git a/eng/pipelines/installer/helix-queues-setup.yml b/eng/pipelines/installer/helix-queues-setup.yml
index 57cd037c9ed28f..582294a4a39d6a 100644
--- a/eng/pipelines/installer/helix-queues-setup.yml
+++ b/eng/pipelines/installer/helix-queues-setup.yml
@@ -42,7 +42,6 @@ jobs:
# Linux x64
- ${{ if eq(parameters.platform, 'linux_x64') }}:
- AzureLinux.3.Amd64.Open
- - Ubuntu.2204.Amd64.Open
# OSX arm64
- ${{ if eq(parameters.platform, 'osx_arm64') }}:
diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
index fdebac85bc327a..71713d3bccb3c7 100644
--- a/eng/pipelines/libraries/helix-queues-setup.yml
+++ b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -37,7 +37,7 @@ jobs:
# Linux musl x64
- ${{ if eq(parameters.platform, 'linux_musl_x64') }}:
- - ${{ if or(eq(parameters.jobParameters.isExtraPlatformsBuild, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
+ - ${{ if or(eq(parameters.jobParameters.isExtraPlatformsBuild, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
- (Alpine.edge.Amd64.Open)AzureLinux.3.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:alpine-edge-helix-amd64
- ${{ if or(ne(parameters.jobParameters.isExtraPlatformsBuild, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
- (Alpine.322.Amd64.Open)AzureLinux.3.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:alpine-3.22-helix-amd64
@@ -75,7 +75,7 @@ jobs:
- Ubuntu.2204.Amd64.Open
- (AzureLinux.3.0.Amd64.Open)AzureLinux.3.Amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-helix-amd64
- (Centos.10.Amd64.Open)AzureLinux.3.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream-10-helix-amd64
-
+
# OSX arm64
- ${{ if eq(parameters.platform, 'osx_arm64') }}:
- osx.13.arm64.open
diff --git a/eng/pipelines/performance/perf-build.yml b/eng/pipelines/performance/perf-build.yml
index ef418994581d99..10cc3606d94bdf 100644
--- a/eng/pipelines/performance/perf-build.yml
+++ b/eng/pipelines/performance/perf-build.yml
@@ -14,10 +14,6 @@ parameters:
displayName: Build Coreclr Arm64 Windows
type: boolean
default: true
-- name: coreclr_muslx64_linux
- displayName: Build Coreclr Musl x64 Linux
- type: boolean
- default: true
- name: coreclr_x64_linux
displayName: Build Coreclr x64 Linux
type: boolean
@@ -110,8 +106,6 @@ extends:
- coreclr_arm64_linux
- ${{ if eq(parameters.coreclr_arm64_windows, true) }}:
- coreclr_arm64_windows
- - ${{ if eq(parameters.coreclr_muslx64_linux, true) }}:
- - coreclr_muslx64_linux
- ${{ if eq(parameters.coreclr_x64_linux, true) }}:
- coreclr_x64_linux
- ${{ if eq(parameters.coreclr_x64_windows, true) }}:
@@ -152,8 +146,6 @@ extends:
- coreclr_arm64_linux
- ${{ if eq(parameters.coreclr_arm64_windows, true) }}:
- coreclr_arm64_windows
- - ${{ if eq(parameters.coreclr_muslx64_linux, true) }}:
- - coreclr_muslx64_linux
- ${{ if eq(parameters.coreclr_x64_linux, true) }}:
- coreclr_x64_linux
- ${{ if eq(parameters.coreclr_x64_windows, true) }}:
@@ -182,7 +174,7 @@ extends:
- nativeAot_arm64_ios
${{ if parameters.mauiFramework }}:
mauiFramework: ${{ parameters.mauiFramework }}
-
+
- ${{ if and(ne(variables['System.TeamProject'], 'public'), or(eq(variables['Build.Reason'], 'IndividualCI'), parameters.runPrivateJobs)) }}:
- stage: UploadArtifacts
displayName: 'Upload Artifacts'
@@ -200,8 +192,6 @@ extends:
- coreclr_arm64_linux
- ${{ if eq(parameters.coreclr_arm64_windows, true) }}:
- coreclr_arm64_windows
- - ${{ if eq(parameters.coreclr_muslx64_linux, true) }}:
- - coreclr_muslx64_linux
- ${{ if eq(parameters.coreclr_x64_linux, true) }}:
- coreclr_x64_linux
- ${{ if eq(parameters.coreclr_x64_windows, true) }}:
diff --git a/eng/pipelines/performance/perf.yml b/eng/pipelines/performance/perf.yml
index 01b80b580db2bd..17b77bffe7e16d 100644
--- a/eng/pipelines/performance/perf.yml
+++ b/eng/pipelines/performance/perf.yml
@@ -8,6 +8,7 @@ trigger:
branches:
include:
- main
+ - release/10.0
- release/9.0
- release/8.0
paths:
diff --git a/eng/pipelines/performance/templates/build-perf-sample-apps.yml b/eng/pipelines/performance/templates/build-perf-sample-apps.yml
index 36ca31eb80ca4d..be23c6465cbd44 100644
--- a/eng/pipelines/performance/templates/build-perf-sample-apps.yml
+++ b/eng/pipelines/performance/templates/build-perf-sample-apps.yml
@@ -20,7 +20,7 @@ steps:
artifactName: AndroidMonoArm64BuildLog
- template: /eng/pipelines/common/upload-artifact-step.yml
parameters:
- rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/Bundle/bin/HelloAndroid.apk
+ rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/AppBundle/bin/HelloAndroid.apk
includeRootFolder: true
displayName: Android Sample App JIT Mono
artifactName: AndroidHelloWorldArm64Mono
@@ -43,7 +43,7 @@ steps:
artifactName: AndroidMonoAOTArm64BuildLog
- template: /eng/pipelines/common/upload-artifact-step.yml
parameters:
- rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/Bundle/bin/HelloAndroid.apk
+ rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/AppBundle/bin/HelloAndroid.apk
includeRootFolder: true
displayName: Android Sample App AOT Mono
artifactName: AndroidHelloWorldArm64MonoAOT
@@ -67,7 +67,7 @@ steps:
artifactName: AndroidCoreCLRArm64BuildLog
- template: /eng/pipelines/common/upload-artifact-step.yml
parameters:
- rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/Bundle/bin/HelloAndroid.apk
+ rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/AppBundle/bin/HelloAndroid.apk
includeRootFolder: true
displayName: Android Sample App JIT CoreCLR
artifactName: AndroidHelloWorldArm64CoreCLR
@@ -90,7 +90,7 @@ steps:
artifactName: AndroidCoreCLRArm64StaticLinkingBuildLog
- template: /eng/pipelines/common/upload-artifact-step.yml
parameters:
- rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/Bundle/bin/HelloAndroid.apk
+ rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/AppBundle/bin/HelloAndroid.apk
includeRootFolder: true
displayName: Android Sample App JIT CoreCLR Static Linking
artifactName: AndroidHelloWorldArm64CoreCLRStaticLinking
@@ -113,7 +113,7 @@ steps:
artifactName: AndroidCoreCLRR2RArm64BuildLog
- template: /eng/pipelines/common/upload-artifact-step.yml
parameters:
- rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/Bundle/bin/HelloAndroid.apk
+ rootFolder: $(Build.SourcesDirectory)/artifacts/bin/AndroidSampleApp/arm64/Release/android-arm64/AppBundle/bin/HelloAndroid.apk
includeRootFolder: true
displayName: Android Sample App R2R CoreCLR
artifactName: AndroidHelloWorldArm64CoreCLRR2R
diff --git a/eng/pipelines/performance/templates/perf-build-jobs.yml b/eng/pipelines/performance/templates/perf-build-jobs.yml
index 4defede2528db2..a7ecb34a3f0f9e 100644
--- a/eng/pipelines/performance/templates/perf-build-jobs.yml
+++ b/eng/pipelines/performance/templates/perf-build-jobs.yml
@@ -8,7 +8,6 @@ jobs:
linux_x64: true
windows_x64: true
windows_x86: true
- linux_musl_x64: true
android_arm64: true
# build mono for AOT
diff --git a/eng/pipelines/performance/templates/perf-coreclr-build-jobs.yml b/eng/pipelines/performance/templates/perf-coreclr-build-jobs.yml
index ddf103aaf4c0d9..85704ada6a297e 100644
--- a/eng/pipelines/performance/templates/perf-coreclr-build-jobs.yml
+++ b/eng/pipelines/performance/templates/perf-coreclr-build-jobs.yml
@@ -1,6 +1,5 @@
parameters:
linux_x64: false
- linux_musl_x64: false
linux_arm64: false
windows_x64: false
windows_x86: false
@@ -8,7 +7,7 @@ parameters:
android_arm64: false
jobs:
- - ${{ if or(eq(parameters.linux_x64, true), eq(parameters.windows_x64, true), eq(parameters.windows_x86, true), eq(parameters.linux_musl_x64, true), eq(parameters.linux_arm64, true), eq(parameters.windows_arm64, true)) }}:
+ - ${{ if or(eq(parameters.linux_x64, true), eq(parameters.windows_x64, true), eq(parameters.windows_x86, true), eq(parameters.linux_arm64, true), eq(parameters.windows_arm64, true)) }}:
# build coreclr and libraries
- template: /eng/pipelines/common/platform-matrix.yml
parameters:
@@ -21,8 +20,6 @@ jobs:
- windows_x64
- ${{ if eq(parameters.windows_x86, true) }}:
- windows_x86
- - ${{ if eq(parameters.linux_musl_x64, true) }}:
- - linux_musl_x64
- ${{ if eq(parameters.linux_arm64, true) }}:
- linux_arm64
- ${{ if eq(parameters.windows_arm64, true) }}:
diff --git a/eng/pipelines/runtime-linker-tests.yml b/eng/pipelines/runtime-linker-tests.yml
index 9df8042e7af0af..3f2e6c1da8b5d1 100644
--- a/eng/pipelines/runtime-linker-tests.yml
+++ b/eng/pipelines/runtime-linker-tests.yml
@@ -82,7 +82,11 @@ extends:
or(
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
eq(variables['isRollingBuild'], true))
- buildArgs: -s tools.illinktests -test -c $(_BuildConfig)
+ # Build libs.sfx subset first so that Roslyn analyzer tests can use live ref pack
+ buildArgs: -s libs.sfx -c $(_BuildConfig)
+ postBuildSteps:
+ - script: $(Build.SourcesDirectory)$(dir)build$(scriptExt) -ci -arch $(archType) $(_osParameter) -s tools.illinktests -test -c $(_BuildConfig) $(crossArg) $(_officialBuildParameter)
+ displayName: Run ILLink Tests
#
# Build Release config vertical for Windows, Linux, and OSX
diff --git a/eng/pipelines/runtime-llvm.yml b/eng/pipelines/runtime-llvm.yml
index b315a1541d1fd8..82f4bb1970a28b 100644
--- a/eng/pipelines/runtime-llvm.yml
+++ b/eng/pipelines/runtime-llvm.yml
@@ -162,7 +162,7 @@ extends:
nameSuffix: AllSubsets_Mono_LLVMFULLAOT_RuntimeTests
runtimeVariant: llvmfullaot
buildArgs: -s mono+libs+clr.hosts+clr.iltools -c $(_BuildConfig) /p:MonoEnableLLVM=true
- timeoutInMinutes: 400
+ timeoutInMinutes: 480
condition: >-
or(
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
@@ -177,9 +177,9 @@ extends:
testRunNamePrefixSuffix: Mono_Release
testBuildArgs: >-
-tree:CoreMangLib -tree:Exceptions -tree:GC -tree:Interop -tree:Loader -tree:Regressions -tree:baseservices
- -tree:ilasm -tree:ilverify -tree:managed -tree:profiler -tree:readytorun -tree:reflection -tree:tracing
+ -tree:ilverify -tree:managed -tree:profiler -tree:reflection -tree:tracing
-tree:JIT/BBT -tree:JIT/CodeGenBringUpTests -tree:JIT/Directed -tree:JIT/Generics -tree:JIT/IL_Conformance
- -tree:JIT/Math -tree:JIT/Methodical -tree:JIT/PGO -tree:JIT/Performance -tree:JIT/Regression -tree:JIT/RyuJIT
+ -tree:JIT/Math -tree:JIT/Methodical -tree:JIT/Performance -tree:JIT/Regression -tree:JIT/RyuJIT
-tree:JIT/Stress -tree:JIT/common -tree:JIT/jit64 -tree:JIT/opt -tree:JIT/superpmi
extraVariablesTemplates:
- template: /eng/pipelines/common/templates/runtimes/test-variables.yml
@@ -209,7 +209,7 @@ extends:
nameSuffix: AllSubsets_Mono_LLVMFULLAOT_RuntimeIntrinsicsTests
runtimeVariant: llvmfullaot
buildArgs: -s mono+libs+clr.hosts+clr.iltools -c $(_BuildConfig) /p:MonoEnableLLVM=true
- timeoutInMinutes: 400
+ timeoutInMinutes: 480
condition: >-
or(
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index 44740dd5181d2e..7460b60a32f93c 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -86,21 +86,6 @@ extends:
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
eq(variables['isRollingBuild'], true))
- - template: /eng/pipelines/common/platform-matrix.yml
- parameters:
- jobTemplate: /eng/pipelines/common/global-build-job.yml
- buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
- platforms:
- - osx_arm64
- jobParameters:
- nameSuffix: AllSubsets_CoreCLR
- buildArgs: -s clr+libs+host+packs -rc Release -c Release -lc $(_BuildConfig)
- timeoutInMinutes: 120
- condition: >-
- or(
- eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
- eq(variables['isRollingBuild'], true))
-
- template: /eng/pipelines/common/platform-matrix.yml
parameters:
jobTemplate: /eng/pipelines/common/global-build-job.yml
@@ -208,6 +193,36 @@ extends:
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
eq(variables['isRollingBuild'], true))
+ #
+ # Build CoreCLR and Libraries
+ # For running installer tests
+ #
+ - template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/common/global-build-job.yml
+ buildConfig: release
+ platforms:
+ - osx_arm64
+ jobParameters:
+ nameSuffix: CoreCLR_Libraries
+ buildArgs: -s clr+libs -c $(_BuildConfig)
+ timeoutInMinutes: 120
+ postBuildSteps:
+ - template: /eng/pipelines/common/upload-artifact-step.yml
+ parameters:
+ rootFolder: $(Build.SourcesDirectory)/artifacts/bin
+ includeRootFolder: false
+ archiveType: $(archiveType)
+ archiveExtension: $(archiveExtension)
+ tarCompression: $(tarCompression)
+ artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
+ displayName: Build Assets
+ condition: >-
+ or(
+ eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
+ eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+ eq(variables['isRollingBuild'], true))
+
#
# Build CoreCLR and Libraries with the respective tests
# for the test configurations we run.
@@ -885,13 +900,13 @@ extends:
# WASI/WASM
- - template: /eng/pipelines/common/templates/simple-wasm-build-tests.yml
- parameters:
- platforms:
- - wasi_wasm
- - wasi_wasm_win
- extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
- alwaysRun: ${{ variables.isRollingBuild }}
+ # - template: /eng/pipelines/common/templates/simple-wasm-build-tests.yml
+ # parameters:
+ # platforms:
+ # - wasi_wasm
+ # - wasi_wasm_win
+ # extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
+ # alwaysRun: ${{ variables.isRollingBuild }}
#
# Android devices
@@ -916,7 +931,7 @@ extends:
testGroup: innerloop
nameSuffix: AllSubsets_Mono
buildArgs: -s mono+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:EnableAdditionalTimezoneChecks=true
- timeoutInMinutes: 480
+ timeoutInMinutes: 120
condition: >-
or(
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
@@ -958,7 +973,7 @@ extends:
testGroup: innerloop
nameSuffix: AllSubsets_CoreCLR
buildArgs: -s clr.runtime+clr.alljits+clr.corelib+clr.nativecorelib+clr.tools+clr.packages+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true
- timeoutInMinutes: 480
+ timeoutInMinutes: 180
condition: >-
or(
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
@@ -1002,7 +1017,7 @@ extends:
testGroup: innerloop
nameSuffix: AllSubsets_Mono
buildArgs: -s mono+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=true /p:RunSmokeTestsOnly=true /p:BuildTestsOnHelix=true /p:EnableAdditionalTimezoneChecks=true /p:UsePortableRuntimePack=false /p:EnableAggressiveTrimming=true
- timeoutInMinutes: 480
+ timeoutInMinutes: 120
condition: >-
or(
eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
@@ -1261,6 +1276,7 @@ extends:
buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
platforms:
- windows_x86
+ - osx_arm64
helixQueuesTemplate: /eng/pipelines/installer/helix-queues-setup.yml
jobParameters:
nameSuffix: Installer_Build_And_Test
diff --git a/eng/references.targets b/eng/references.targets
index 2b0035d3054a1f..6edd9720538136 100644
--- a/eng/references.targets
+++ b/eng/references.targets
@@ -1,4 +1,5 @@
+
<_coreLibProjectReference Include="@(ProjectReference->WithMetadataValue('Identity', '$(CoreLibProject)'))" />
-
+ Configuration=$(CoreCLRConfiguration)Configuration=$(MonoConfiguration)
-
-
-
-
-
-
-
-
+
+
+ <_ProjectReferenceWithOriginalIdentity Include="@(ProjectReference)"
+ OriginalIdentity="%(Identity)" />
+ <_projectReferenceWithFilename Include="@(_ProjectReferenceWithOriginalIdentity->Metadata('Filename'))" />
+
+ <_projectReferenceExcludedWithFilename Include="@(_projectReferenceWithFilename)"
+ Exclude="@(NetCoreAppLibrary)" />
+ <_frameworkProjectReference Include="@(_projectReferenceWithFilename)"
+ Exclude="@(_projectReferenceExcludedWithFilename)" />
+
+
+ all
+ false
+
+
+
diff --git a/eng/resolveContract.targets b/eng/resolveContract.targets
index 14bf17e8ed4f93..e9f2e0b48a0873 100644
--- a/eng/resolveContract.targets
+++ b/eng/resolveContract.targets
@@ -119,6 +119,7 @@
true
+ ReferencePathWithRefAssemblies
diff --git a/eng/slngen.targets b/eng/slngen.targets
index d7622098f1e42d..382ca8d684aad5 100644
--- a/eng/slngen.targets
+++ b/eng/slngen.targets
@@ -4,7 +4,7 @@
$(SlnGenSolutionFolder)gen$(SlnGenSolutionInnerFolder)$(SlnGenSolutionFolder)ref$(SlnGenSolutionInnerFolder)$(SlnGenSolutionFolder)tests$(SlnGenSolutionInnerFolder)
- $(SlnGenSolutionFolder)src$(SlnGenSolutionInnerFolder)
+ $(SlnGenSolutionFolder)src$(SlnGenSolutionInnerFolder)
diff --git a/eng/targetingpacks.targets b/eng/targetingpacks.targets
index 6869d63c852186..15e62c05e04b4e 100644
--- a/eng/targetingpacks.targets
+++ b/eng/targetingpacks.targets
@@ -1,16 +1,16 @@
-
-
+
+
$(MicrosoftNetCoreAppFrameworkName)true
@@ -90,26 +90,6 @@
Condition="'$(UseLocalAppHostPack)' == 'true' and '@(KnownAppHostPack->AnyHaveMetadataValue('TargetFramework', '$(NetCoreAppCurrent)'))' != 'true'" />
-
-
-
- false
-
-
-
-
-
-
- $(AssemblySearchPaths);$(MicrosoftNetCoreAppRefPackRefDir.TrimEnd('/\'))
- $(DesignTimeAssemblySearchPaths);$(MicrosoftNetCoreAppRefPackRefDir.TrimEnd('/\'))
-
-
-
$(BootstrapRuntimePackDir)/runtimes/$(TargetRid)/native/
$(BootstrapAotSdkDir)/
+
diff --git a/eng/testing/BrowserVersions.props b/eng/testing/BrowserVersions.props
index e09e3c3be90ca0..c7b40839e4a520 100644
--- a/eng/testing/BrowserVersions.props
+++ b/eng/testing/BrowserVersions.props
@@ -1,13 +1,13 @@
- 138.0.7204.49
- 1465706
- https://storage.googleapis.com/chromium-browser-snapshots/Linux_x64/1465706
- 13.8.258
- 138.0.7204.35
- 1465706
- https://storage.googleapis.com/chromium-browser-snapshots/Win_x64/1465706
- 13.8.258
+ 139.0.7258.127
+ 1477651
+ https://storage.googleapis.com/chromium-browser-snapshots/Linux_x64/1477657
+ 13.9.205
+ 139.0.7258.66
+ 1477651
+ https://storage.googleapis.com/chromium-browser-snapshots/Win_x64/1477667
+ 13.9.205125.0.10.34.0125.0.1
diff --git a/eng/testing/scenarios/BuildWasiAppsJobsList.txt b/eng/testing/scenarios/BuildWasiAppsJobsList.txt
index 86c0517585a480..8b137891791fe9 100644
--- a/eng/testing/scenarios/BuildWasiAppsJobsList.txt
+++ b/eng/testing/scenarios/BuildWasiAppsJobsList.txt
@@ -1,7 +1 @@
-Wasi.Build.Tests.InvariantTests
-Wasi.Build.Tests.ILStripTests
-Wasi.Build.Tests.SdkMissingTests
-Wasi.Build.Tests.RuntimeConfigTests
-Wasi.Build.Tests.WasiTemplateTests
-Wasi.Build.Tests.PInvokeTableGeneratorTests
-Wasi.Build.Tests.WasiLibraryModeTests
+
diff --git a/eng/testing/scenarios/BuildWasmAppsJobsList.txt b/eng/testing/scenarios/BuildWasmAppsJobsList.txt
index 82c8b0c827964d..60f2a2187e3e14 100644
--- a/eng/testing/scenarios/BuildWasmAppsJobsList.txt
+++ b/eng/testing/scenarios/BuildWasmAppsJobsList.txt
@@ -14,7 +14,6 @@ Wasm.Build.Tests.Blazor.DllImportTests
Wasm.Build.Tests.Blazor.NativeTests
Wasm.Build.Tests.Blazor.NoopNativeRebuildTest
Wasm.Build.Tests.Blazor.WorkloadRequiredTests
-Wasm.Build.Tests.Blazor.SignalRClientTests
Wasm.Build.Tests.Blazor.EventPipeDiagnosticsTests
Wasm.Build.Tests.BuildPublishTests
Wasm.Build.Tests.ConfigSrcTests
@@ -38,7 +37,6 @@ Wasm.Build.Tests.LibraryInitializerTests
Wasm.Build.Tests.SatelliteLoadingTests
Wasm.Build.Tests.ModuleConfigTests
Wasm.Build.Tests.MemoryTests
-Wasm.Build.Tests.AspNetCore.SignalRClientTests
Wasm.Build.Tests.WasmBuildAppTest
Wasm.Build.Tests.WasmNativeDefaultsTests
Wasm.Build.Tests.WasmRunOutOfAppBundleTests
diff --git a/eng/testing/tests.android.targets b/eng/testing/tests.android.targets
index 4144799c78f908..5bcd9d4bc63d2e 100644
--- a/eng/testing/tests.android.targets
+++ b/eng/testing/tests.android.targets
@@ -28,7 +28,6 @@
AndroidTestRunner.dll$(PublishDir)
- $(BundleDir)
diff --git a/eng/testing/tests.singlefile.targets b/eng/testing/tests.singlefile.targets
index fab26560f4b61f..05b2c15a018946 100644
--- a/eng/testing/tests.singlefile.targets
+++ b/eng/testing/tests.singlefile.targets
@@ -1,8 +1,8 @@
- Exe
+ Exe
- $([MSBuild]::NormalizeDirectory('$(OutDir)', 'publish'))
+ $([MSBuild]::NormalizeDirectory('$(OutDir)', 'publish'))$([MSBuild]::NormalizePath('$(BundleDir)', '$(RunScriptOutputName)'))$(TargetRid)
@@ -49,7 +49,8 @@
+ Link="Common\SingleFileTestRunner\SingleFileTestRunner.cs"
+ Condition="'$(IsFunctionalTest)' != 'true'" />
diff --git a/github-merge-flow.jsonc b/github-merge-flow.jsonc
index b42b4e156afa38..0439bc3c57e163 100644
--- a/github-merge-flow.jsonc
+++ b/github-merge-flow.jsonc
@@ -15,6 +15,11 @@
"release/9.0":{
"MergeToBranch": "release/9.0-staging",
"ExtraSwitches": "-QuietComments"
+ },
+ // Automate merging runtime release/10.0-rc1 branch into release/10.0
+ "release/10.0-rc1":{
+ "MergeToBranch": "release/10.0",
+ "ExtraSwitches": "-QuietComments"
}
}
}
diff --git a/global.json b/global.json
index 35c4959162e898..7f8070a6693aec 100644
--- a/global.json
+++ b/global.json
@@ -1,18 +1,18 @@
{
"sdk": {
- "version": "10.0.100-preview.6.25315.102",
+ "version": "10.0.100-rc.1.25411.109",
"allowPrerelease": true,
"rollForward": "major"
},
"tools": {
- "dotnet": "10.0.100-preview.6.25315.102"
+ "dotnet": "10.0.100-rc.1.25411.109"
},
"msbuild-sdks": {
- "Microsoft.DotNet.Arcade.Sdk": "10.0.0-beta.25351.106",
- "Microsoft.DotNet.Helix.Sdk": "10.0.0-beta.25351.106",
- "Microsoft.DotNet.SharedFramework.Sdk": "10.0.0-beta.25351.106",
+ "Microsoft.DotNet.Arcade.Sdk": "10.0.0-beta.25418.105",
+ "Microsoft.DotNet.Helix.Sdk": "10.0.0-beta.25418.105",
+ "Microsoft.DotNet.SharedFramework.Sdk": "10.0.0-beta.25418.105",
"Microsoft.Build.NoTargets": "3.7.0",
"Microsoft.Build.Traversal": "3.4.0",
- "Microsoft.NET.Sdk.IL": "10.0.0-preview.7.25351.106"
+ "Microsoft.NET.Sdk.IL": "10.0.0-rc.1.25418.105"
}
}
diff --git a/src/coreclr/.nuget/ILCompiler.Reflection.ReadyToRun.Experimental/ILCompiler.Reflection.ReadyToRun.Experimental.pkgproj b/src/coreclr/.nuget/ILCompiler.Reflection.ReadyToRun.Experimental/ILCompiler.Reflection.ReadyToRun.Experimental.pkgproj
index 0480327017db55..7d202885cc77c5 100644
--- a/src/coreclr/.nuget/ILCompiler.Reflection.ReadyToRun.Experimental/ILCompiler.Reflection.ReadyToRun.Experimental.pkgproj
+++ b/src/coreclr/.nuget/ILCompiler.Reflection.ReadyToRun.Experimental/ILCompiler.Reflection.ReadyToRun.Experimental.pkgproj
@@ -12,11 +12,11 @@
- \lib\netstandard2.0\
+ \lib\$(NetCoreAppMinimum)\$(SystemReflectionMetadataVersion)
- netstandard2.0
+ $(NetCoreAppMinimum)Build,Analyzers
diff --git a/src/coreclr/CMakeLists.txt b/src/coreclr/CMakeLists.txt
index 7286f655004ca9..b1433e14def45b 100644
--- a/src/coreclr/CMakeLists.txt
+++ b/src/coreclr/CMakeLists.txt
@@ -39,6 +39,10 @@ if (DEFINED CLR_CMAKE_ICU_DIR)
include_directories(${CLR_CMAKE_ICU_DIR}/include)
endif(DEFINED CLR_CMAKE_ICU_DIR)
+if (CLR_CMAKE_TARGET_ARCH_WASM)
+ add_compile_options(-fwasm-exceptions)
+endif()
+
#----------------------------------------------------
# Cross target Component build specific configuration
#----------------------------------------------------
@@ -174,6 +178,12 @@ endif(CLR_CMAKE_HOST_WIN32)
#----------------------------------
include(clrdefinitions.cmake)
+#--------------------------------
+# Data descriptors mechanics
+# - all clr specific data descriptor helpers should be included in this file
+#----------------------------------
+include(clrdatadescriptors.cmake)
+
if(FEATURE_STANDALONE_GC)
add_definitions(-DFEATURE_STANDALONE_GC)
endif(FEATURE_STANDALONE_GC)
diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj
index 2fb4c3e7ffa6bb..c12d6c854ac0c0 100644
--- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj
+++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj
@@ -223,6 +223,7 @@
+
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs
index 7fbb594a1844de..3634e8012c21fd 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs
@@ -170,7 +170,7 @@ private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type t
{
rtAdd = rtAdd.GetParentDefinition();
if (rtAdd != null)
- return rtAdd.DeclaringType!.GetEvent(ev.Name!);
+ return rtAdd.DeclaringType!.GetEvent(ev.Name);
}
return null;
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs
index 4e0736cb78aa4f..763259a20a257e 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs
@@ -118,7 +118,7 @@ internal void InitializeSourceInfo(bool fNeedFileInfo, Exception? exception)
// ENC or the source/line info was already retrieved, the method token is 0.
if (rgiMethodToken![index] != 0)
{
- GetSourceLineInfo(s_stackTraceSymbolsCache!, rgAssembly![index], rgAssemblyPath![index]!, rgLoadedPeAddress![index], rgiLoadedPeSize![index], rgiIsFileLayout![index],
+ GetSourceLineInfo(s_stackTraceSymbolsCache, rgAssembly![index], rgAssemblyPath![index], rgLoadedPeAddress![index], rgiLoadedPeSize![index], rgiIsFileLayout![index],
rgInMemoryPdbAddress![index], rgiInMemoryPdbSize![index], rgiMethodToken![index],
rgiILOffset![index], out rgFilename![index], out rgiLineNumber![index], out rgiColumnNumber![index]);
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs
index 101fbfa7c6bc45..5b05fe76d08136 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs
@@ -884,7 +884,7 @@ private static unsafe void ConfigCallback(void* configurationContext, void* name
ref GCConfigurationContext context = ref Unsafe.As(ref *(byte*)configurationContext);
Debug.Assert(context.Configurations != null);
- Dictionary configurationDictionary = context.Configurations!;
+ Dictionary configurationDictionary = context.Configurations;
string nameAsString = Marshal.PtrToStringUTF8((IntPtr)name)!;
switch (type)
diff --git a/src/coreclr/System.Private.CoreLib/src/System/MulticastDelegate.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/MulticastDelegate.CoreCLR.cs
index 9740d23843f42b..1c9a4c6c384b29 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/MulticastDelegate.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/MulticastDelegate.CoreCLR.cs
@@ -9,6 +9,7 @@
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
+using System.Threading;
namespace System
{
@@ -144,7 +145,7 @@ private bool InvocationListEquals(MulticastDelegate d)
private static bool TrySetSlot(object?[] a, int index, object o)
{
- if (a[index] == null && Threading.Interlocked.CompareExchange(ref a[index], o, null) == null)
+ if (a[index] == null && Interlocked.CompareExchange(ref a[index], o, null) == null)
return true;
// The slot may be already set because we have added and removed the same method before.
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs
index 2aad5096f25f05..5c5bc5d0e52217 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs
@@ -416,7 +416,7 @@ private static MethodBase GetGenericMethodBaseDefinition(MethodBase methodBase)
{
Debug.Assert(masmi != null);
- methDef = masmi.GetGenericMethodDefinition()!;
+ methDef = masmi.GetGenericMethodDefinition();
methDef = methDef.Module.ResolveMethod(
methodBase.MetadataToken,
methDef.DeclaringType?.GetGenericArguments(),
@@ -1070,7 +1070,7 @@ internal int GetMethodTokenInternal(MethodBase method, Type[]? optionalParameter
if (!isGenericMethodDef)
{
- methodInfoUnbound = methodInfo.GetGenericMethodDefinition()!;
+ methodInfoUnbound = methodInfo.GetGenericMethodDefinition();
}
if (!Equals(methodInfoUnbound.Module)
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
index 17bb50457648f5..f9c11e07891095 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
@@ -34,7 +34,7 @@ internal sealed partial class RuntimeAssembly : Assembly
#endregion
- internal IntPtr GetUnderlyingNativeHandle() { return m_assembly; }
+ internal IntPtr GetUnderlyingNativeHandle() => m_assembly;
private sealed class ManifestResourceStream : UnmanagedMemoryStream
{
@@ -52,17 +52,8 @@ internal unsafe ManifestResourceStream(RuntimeAssembly manifestAssembly, byte* p
// NOTE: no reason to override Write(Span), since a ManifestResourceStream is read-only.
}
- internal object SyncRoot
- {
- get
- {
- if (m_syncRoot == null)
- {
- Interlocked.CompareExchange(ref m_syncRoot, new object(), null);
- }
- return m_syncRoot;
- }
- }
+ internal object SyncRoot =>
+ m_syncRoot ?? Interlocked.CompareExchange(ref m_syncRoot, new object(), null) ?? m_syncRoot;
public override event ModuleResolveEventHandler? ModuleResolve
{
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs
index eab9a97e8ba8e4..de2f6cf1d2d197 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs
@@ -170,7 +170,7 @@ internal static CustomAttributeEncoding TypeToCustomAttributeEncoding(RuntimeTyp
if (type.IsClass)
return CustomAttributeEncoding.Object;
- if (type.IsInterface)
+ if (type.IsActualInterface)
return CustomAttributeEncoding.Object;
if (type.IsActualValueType)
@@ -253,10 +253,10 @@ private RuntimeCustomAttributeData(RuntimeModule scope, MetadataToken caCtorToke
m_scope = scope;
m_ctor = (RuntimeConstructorInfo)RuntimeType.GetMethodBase(m_scope, caCtorToken)!;
- if (m_ctor!.DeclaringType!.IsGenericType)
+ if (m_ctor.DeclaringType!.IsGenericType)
{
MetadataImport metadataScope = m_scope.MetadataImport;
- Type attributeType = m_scope.ResolveType(metadataScope.GetParentToken(caCtorToken), null, null)!;
+ Type attributeType = m_scope.ResolveType(metadataScope.GetParentToken(caCtorToken), null, null);
m_ctor = (RuntimeConstructorInfo)m_scope.ResolveMethod(caCtorToken, attributeType.GenericTypeArguments, null)!.MethodHandle.GetMethodInfo();
}
@@ -1270,12 +1270,12 @@ internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caTyp
for (int i = 0; i < pcas.Count; i++)
result.Add(pcas[i]);
- while (type != (RuntimeType)typeof(object) && type != null)
+ do
{
AddCustomAttributes(ref result, type.GetRuntimeModule(), type.MetadataToken, caType, mustBeInheritable, result);
mustBeInheritable = true;
type = (type.BaseType as RuntimeType)!;
- }
+ } while (type != (RuntimeType)typeof(object) && type != null);
object[] typedResult = CreateAttributeArrayHelper(caType, result.Count);
for (int i = 0; i < result.Count; i++)
@@ -2263,7 +2263,7 @@ internal static bool IsDefined(RuntimeFieldInfo field, RuntimeType? caType)
internal static StructLayoutAttribute? GetStructLayoutCustomAttribute(RuntimeType type)
{
- if (type.IsInterface || type.HasElementType || type.IsGenericParameter)
+ if (type.IsActualInterface || type.HasElementType || type.IsGenericParameter)
return null;
LayoutKind layoutKind = LayoutKind.Auto;
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs
index a4bd430b620082..3a72a2e1174e4b 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs
@@ -105,7 +105,7 @@ Signature LazyCreateSignature()
internal RuntimeMethodInfo? GetParentDefinition()
{
- if (!IsVirtual || m_declaringType.IsInterface)
+ if (!IsVirtual || m_declaringType.IsActualInterface)
return null;
RuntimeType? parent = (RuntimeType?)m_declaringType.BaseType;
@@ -323,7 +323,7 @@ internal void InvokePropertySetter(object? obj, BindingFlags invokeAttr, Binder?
public override MethodInfo GetBaseDefinition()
{
- if (!IsVirtual || IsStatic || m_declaringType == null || m_declaringType.IsInterface)
+ if (!IsVirtual || IsStatic || m_declaringType == null || m_declaringType.IsActualInterface)
return this;
int slot = RuntimeMethodHandle.GetSlot(this);
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
index 51b1f84864b1a9..8666910e37318b 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
@@ -305,7 +305,7 @@ internal ReadOnlySpan GetIndexParametersSpan()
Array.Empty();
for (int i = 0; i < propParams.Length; i++)
- propParams[i] = new RuntimeParameterInfo((RuntimeParameterInfo)methParams![i], this);
+ propParams[i] = new RuntimeParameterInfo((RuntimeParameterInfo)methParams[i], this);
m_parameters = propParams;
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs
index b9b6dbb87947c0..ba703738d3c7c3 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs
@@ -61,6 +61,15 @@ internal enum CorInfoContinuationFlags
// OSR method saved in the beginning of 'Data', or -1 if the continuation
// belongs to a tier 0 method.
CORINFO_CONTINUATION_OSR_IL_OFFSET_IN_DATA = 4,
+ // If this bit is set the continuation should continue on the thread
+ // pool.
+ CORINFO_CONTINUATION_CONTINUE_ON_THREAD_POOL = 8,
+ // If this bit is set the continuation has a SynchronizationContext
+ // that we should continue on.
+ CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_SYNCHRONIZATION_CONTEXT = 16,
+ // If this bit is set the continuation has a TaskScheduler
+ // that we should continue on.
+ CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_TASK_SCHEDULER = 32,
}
internal sealed unsafe class Continuation
@@ -93,6 +102,29 @@ internal sealed unsafe class Continuation
//
public byte[]? Data;
public object?[]? GCData;
+
+ public object GetContinuationContext()
+ {
+ int index = 0;
+ if ((Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_RESULT_IN_GCDATA) != 0)
+ index++;
+ if ((Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_NEEDS_EXCEPTION) != 0)
+ index++;
+ Debug.Assert(GCData != null && GCData.Length > index);
+ object? continuationContext = GCData[index];
+ Debug.Assert(continuationContext != null);
+ return continuationContext;
+ }
+
+ public void SetException(Exception ex)
+ {
+ int index = 0;
+ if ((Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_RESULT_IN_GCDATA) != 0)
+ index++;
+
+ Debug.Assert(GCData != null && GCData.Length > index);
+ GCData[index] = ex;
+ }
}
public static partial class AsyncHelpers
@@ -171,122 +203,338 @@ private static unsafe object AllocContinuationResultBox(void* ptr)
return RuntimeTypeHandle.InternalAllocNoChecks((MethodTable*)pMT);
}
- // wrapper to await a notifier
- private struct AwaitableProxy : ICriticalNotifyCompletion
+ private interface IThunkTaskOps
{
- private readonly INotifyCompletion _notifier;
+ static abstract Action GetContinuationAction(T task);
+ static abstract Continuation GetContinuationState(T task);
+ static abstract void SetContinuationState(T task, Continuation value);
+ static abstract bool SetCompleted(T task, Continuation continuation);
+ static abstract void PostToSyncContext(T task, SynchronizationContext syncCtx);
+ }
+
+ private sealed class ThunkTask : Task
+ {
+ public ThunkTask()
+ {
+ // We use the base Task's state object field to store the Continuation while posting the task around.
+ // Ensure that state object isn't published out for others to see.
+ Debug.Assert((m_stateFlags & (int)InternalTaskOptions.PromiseTask) != 0, "Expected state flags to already be configured.");
+ Debug.Assert(m_stateObject is null, "Expected to be able to use the state object field for Continuation.");
+ m_action = MoveNext;
+ m_stateFlags |= (int)InternalTaskOptions.HiddenState;
+ }
- public AwaitableProxy(INotifyCompletion notifier)
+ internal override void ExecuteFromThreadPool(Thread threadPoolThread)
{
- _notifier = notifier;
+ MoveNext();
}
- public bool IsCompleted => false;
+ private void MoveNext()
+ {
+ ThunkTaskCore.MoveNext, Ops>(this);
+ }
- public void OnCompleted(Action action)
+ public void HandleSuspended()
{
- _notifier!.OnCompleted(action);
+ ThunkTaskCore.HandleSuspended, Ops>(this);
}
- public AwaitableProxy GetAwaiter() { return this; }
+ private static readonly SendOrPostCallback s_postCallback = static state =>
+ {
+ Debug.Assert(state is ThunkTask);
+ ((ThunkTask)state).MoveNext();
+ };
- public void UnsafeOnCompleted(Action action)
+ private struct Ops : IThunkTaskOps>
{
- if (_notifier is ICriticalNotifyCompletion criticalNotification)
+ public static Action GetContinuationAction(ThunkTask task) => (Action)task.m_action!;
+ public static void MoveNext(ThunkTask task) => task.MoveNext();
+ public static Continuation GetContinuationState(ThunkTask task) => (Continuation)task.m_stateObject!;
+ public static void SetContinuationState(ThunkTask task, Continuation value)
{
- criticalNotification.UnsafeOnCompleted(action);
+ task.m_stateObject = value;
+ }
+
+ public static bool SetCompleted(ThunkTask task, Continuation continuation)
+ {
+ T result;
+ if (RuntimeHelpers.IsReferenceOrContainsReferences())
+ {
+ if (typeof(T).IsValueType)
+ {
+ result = Unsafe.As(ref continuation.GCData![0]!.GetRawData());
+ }
+ else
+ {
+ result = Unsafe.As(ref continuation.GCData![0]!);
+ }
+ }
+ else
+ {
+ result = Unsafe.As(ref continuation.Data![0]);
+ }
+
+ return task.TrySetResult(result);
}
- else
+
+ public static void PostToSyncContext(ThunkTask task, SynchronizationContext syncContext)
{
- _notifier!.OnCompleted(action);
+ syncContext.Post(s_postCallback, task);
}
}
-
- public void GetResult() { }
}
- private static Continuation UnlinkHeadContinuation(out AwaitableProxy awaitableProxy)
+ private sealed class ThunkTask : Task
{
- ref RuntimeAsyncAwaitState state = ref t_runtimeAsyncAwaitState;
- awaitableProxy = new AwaitableProxy(state.Notifier!);
- state.Notifier = null;
-
- Continuation sentinelContinuation = state.SentinelContinuation!;
- Continuation head = sentinelContinuation.Next!;
- sentinelContinuation.Next = null;
- return head;
- }
+ public ThunkTask()
+ {
+ // We use the base Task's state object field to store the Continuation while posting the task around.
+ // Ensure that state object isn't published out for others to see.
+ Debug.Assert((m_stateFlags & (int)InternalTaskOptions.PromiseTask) != 0, "Expected state flags to already be configured.");
+ Debug.Assert(m_stateObject is null, "Expected to be able to use the state object field for Continuation.");
+ m_action = MoveNext;
+ m_stateFlags |= (int)InternalTaskOptions.HiddenState;
+ }
- // When a Task-returning thunk gets a continuation result
- // it calls here to make a Task that awaits on the current async state.
- // NOTE: This cannot be Runtime Async. Must use C# state machine or make one by hand.
- private static async Task FinalizeTaskReturningThunk(Continuation continuation)
- {
- Continuation finalContinuation = new Continuation();
+ internal override void ExecuteFromThreadPool(Thread threadPoolThread)
+ {
+ MoveNext();
+ }
- // Note that the exact location the return value is placed is tied
- // into getAsyncResumptionStub in the VM, so do not change this
- // without also changing that code (and the JIT).
- if (RuntimeHelpers.IsReferenceOrContainsReferences())
+ private void MoveNext()
{
- finalContinuation.Flags = CorInfoContinuationFlags.CORINFO_CONTINUATION_RESULT_IN_GCDATA | CorInfoContinuationFlags.CORINFO_CONTINUATION_NEEDS_EXCEPTION;
- finalContinuation.GCData = new object[1];
+ ThunkTaskCore.MoveNext(this);
}
- else
+
+ public void HandleSuspended()
{
- finalContinuation.Flags = CorInfoContinuationFlags.CORINFO_CONTINUATION_NEEDS_EXCEPTION;
- finalContinuation.Data = new byte[Unsafe.SizeOf()];
+ ThunkTaskCore.HandleSuspended(this);
}
- continuation.Next = finalContinuation;
+ private static readonly SendOrPostCallback s_postCallback = static state =>
+ {
+ Debug.Assert(state is ThunkTask);
+ ((ThunkTask)state).MoveNext();
+ };
- while (true)
+ private struct Ops : IThunkTaskOps
{
- Continuation headContinuation = UnlinkHeadContinuation(out var awaitableProxy);
- await awaitableProxy;
- Continuation? finalResult = DispatchContinuations(headContinuation);
- if (finalResult != null)
+ public static Action GetContinuationAction(ThunkTask task) => (Action)task.m_action!;
+ public static void MoveNext(ThunkTask task) => task.MoveNext();
+ public static Continuation GetContinuationState(ThunkTask task) => (Continuation)task.m_stateObject!;
+ public static void SetContinuationState(ThunkTask task, Continuation value)
{
- Debug.Assert(finalResult == finalContinuation);
- if (RuntimeHelpers.IsReferenceOrContainsReferences())
+ task.m_stateObject = value;
+ }
+
+ public static bool SetCompleted(ThunkTask task, Continuation continuation)
+ {
+ return task.TrySetResult();
+ }
+
+ public static void PostToSyncContext(ThunkTask task, SynchronizationContext syncContext)
+ {
+ syncContext.Post(s_postCallback, task);
+ }
+ }
+ }
+
+ private static class ThunkTaskCore
+ {
+ public static unsafe void MoveNext(T task) where T : Task where TOps : IThunkTaskOps
+ {
+ ExecutionAndSyncBlockStore contexts = default;
+ contexts.Push();
+ Continuation continuation = TOps.GetContinuationState(task);
+
+ while (true)
+ {
+ try
{
- if (typeof(T).IsValueType)
+ Continuation? newContinuation = continuation.Resume(continuation);
+
+ if (newContinuation != null)
{
- return Unsafe.As(ref finalResult.GCData![0]!.GetRawData());
+ newContinuation.Next = continuation.Next;
+ HandleSuspended(task);
+ contexts.Pop();
+ return;
}
- return Unsafe.As(ref finalResult.GCData![0]!);
+ Debug.Assert(continuation.Next != null);
+ continuation = continuation.Next;
+ }
+ catch (Exception ex)
+ {
+ Continuation nextContinuation = UnwindToPossibleHandler(continuation);
+ if (nextContinuation.Resume == null)
+ {
+ // Tail of AsyncTaskMethodBuilderT.SetException
+ bool successfullySet = ex is OperationCanceledException oce ?
+ task.TrySetCanceled(oce.CancellationToken, oce) :
+ task.TrySetException(ex);
+
+ contexts.Pop();
+
+ if (!successfullySet)
+ {
+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
+ }
+
+ return;
+ }
+
+ nextContinuation.SetException(ex);
+
+ continuation = nextContinuation;
+ }
+
+ if (continuation.Resume == null)
+ {
+ bool successfullySet = TOps.SetCompleted(task, continuation);
+
+ contexts.Pop();
+
+ if (!successfullySet)
+ {
+ ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
+ }
+
+ return;
+ }
+
+ if (QueueContinuationFollowUpActionIfNecessary(task, continuation))
+ {
+ contexts.Pop();
+ return;
+ }
+ }
+ }
+
+ private static Continuation UnwindToPossibleHandler(Continuation continuation)
+ {
+ while (true)
+ {
+ Debug.Assert(continuation.Next != null);
+ continuation = continuation.Next;
+ if ((continuation.Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_NEEDS_EXCEPTION) != 0)
+ return continuation;
+ }
+ }
+
+ public static void HandleSuspended(T task) where T : Task where TOps : IThunkTaskOps
+ {
+ Continuation headContinuation = UnlinkHeadContinuation(out INotifyCompletion? notifier);
+
+ // Head continuation should be the result of async call to AwaitAwaiter or UnsafeAwaitAwaiter.
+ // These never have special continuation handling.
+ const CorInfoContinuationFlags continueFlags =
+ CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_SYNCHRONIZATION_CONTEXT |
+ CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_THREAD_POOL |
+ CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_TASK_SCHEDULER;
+ Debug.Assert((headContinuation.Flags & continueFlags) == 0);
+
+ TOps.SetContinuationState(task, headContinuation);
+
+ try
+ {
+ if (notifier is ICriticalNotifyCompletion crit)
+ {
+ crit.UnsafeOnCompleted(TOps.GetContinuationAction(task));
}
else
{
- return Unsafe.As(ref finalResult.Data![0]);
+ Debug.Assert(notifier != null);
+ notifier.OnCompleted(TOps.GetContinuationAction(task));
}
}
+ catch (Exception ex)
+ {
+ Task.ThrowAsync(ex, targetContext: null);
+ }
}
- }
- private static async Task FinalizeTaskReturningThunk(Continuation continuation)
- {
- Continuation finalContinuation = new Continuation
+ private static Continuation UnlinkHeadContinuation(out INotifyCompletion? notifier)
{
- Flags = CorInfoContinuationFlags.CORINFO_CONTINUATION_NEEDS_EXCEPTION,
- };
- continuation.Next = finalContinuation;
+ ref RuntimeAsyncAwaitState state = ref t_runtimeAsyncAwaitState;
+ notifier = state.Notifier;
+ state.Notifier = null;
+
+ Continuation sentinelContinuation = state.SentinelContinuation!;
+ Continuation head = sentinelContinuation.Next!;
+ sentinelContinuation.Next = null;
+ return head;
+ }
- while (true)
+ private static bool QueueContinuationFollowUpActionIfNecessary(T task, Continuation continuation) where T : Task where TOps : IThunkTaskOps
{
- Continuation headContinuation = UnlinkHeadContinuation(out var awaitableProxy);
- await awaitableProxy;
- Continuation? finalResult = DispatchContinuations(headContinuation);
- if (finalResult != null)
+ if ((continuation.Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_THREAD_POOL) != 0)
{
- Debug.Assert(finalResult == finalContinuation);
- return;
+ SynchronizationContext? ctx = Thread.CurrentThreadAssumedInitialized._synchronizationContext;
+ if (ctx == null || ctx.GetType() == typeof(SynchronizationContext))
+ {
+ TaskScheduler? sched = TaskScheduler.InternalCurrent;
+ if (sched == null || sched == TaskScheduler.Default)
+ {
+ // Can inline
+ return false;
+ }
+ }
+
+ TOps.SetContinuationState(task, continuation);
+ ThreadPool.UnsafeQueueUserWorkItemInternal(task, preferLocal: true);
+ return true;
}
+
+ if ((continuation.Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_SYNCHRONIZATION_CONTEXT) != 0)
+ {
+ object continuationContext = continuation.GetContinuationContext();
+ Debug.Assert(continuationContext is SynchronizationContext { });
+ SynchronizationContext continuationSyncCtx = (SynchronizationContext)continuationContext;
+
+ if (continuationSyncCtx == Thread.CurrentThreadAssumedInitialized._synchronizationContext)
+ {
+ // Inline
+ return false;
+ }
+
+ TOps.SetContinuationState(task, continuation);
+
+ try
+ {
+ TOps.PostToSyncContext(task, continuationSyncCtx);
+ }
+ catch (Exception ex)
+ {
+ Task.ThrowAsync(ex, targetContext: null);
+ }
+
+ return true;
+ }
+
+ if ((continuation.Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_TASK_SCHEDULER) != 0)
+ {
+ object continuationContext = continuation.GetContinuationContext();
+ Debug.Assert(continuationContext is TaskScheduler { });
+ TaskScheduler sched = (TaskScheduler)continuationContext;
+
+ TOps.SetContinuationState(task, continuation);
+ // TODO: We do not need TaskSchedulerAwaitTaskContinuation here, just need to refactor its Run method...
+ var taskSchedCont = new TaskSchedulerAwaitTaskContinuation(sched, TOps.GetContinuationAction(task), flowExecutionContext: false);
+ taskSchedCont.Run(Task.CompletedTask, canInlineContinuationTask: true);
+
+ return true;
+ }
+
+ return false;
}
}
- private static async ValueTask FinalizeValueTaskReturningThunk(Continuation continuation)
+ // Change return type to ThunkTask -- no benefit since this is used for Task returning thunks only
+#pragma warning disable CA1859
+ // When a Task-returning thunk gets a continuation result
+ // it calls here to make a Task that awaits on the current async state.
+ private static Task FinalizeTaskReturningThunk(Continuation continuation)
{
Continuation finalContinuation = new Continuation();
@@ -306,32 +554,12 @@ private static async Task FinalizeTaskReturningThunk(Continuation continuation)
continuation.Next = finalContinuation;
- while (true)
- {
- Continuation headContinuation = UnlinkHeadContinuation(out var awaitableProxy);
- await awaitableProxy;
- Continuation? finalResult = DispatchContinuations(headContinuation);
- if (finalResult != null)
- {
- Debug.Assert(finalResult == finalContinuation);
- if (RuntimeHelpers.IsReferenceOrContainsReferences())
- {
- if (typeof(T).IsValueType)
- {
- return Unsafe.As(ref finalResult.GCData![0]!.GetRawData());
- }
-
- return Unsafe.As(ref finalResult.GCData![0]!);
- }
- else
- {
- return Unsafe.As(ref finalResult.Data![0]);
- }
- }
- }
+ ThunkTask result = new();
+ result.HandleSuspended();
+ return result;
}
- private static async ValueTask FinalizeValueTaskReturningThunk(Continuation continuation)
+ private static Task FinalizeTaskReturningThunk(Continuation continuation)
{
Continuation finalContinuation = new Continuation
{
@@ -339,89 +567,82 @@ private static async ValueTask FinalizeValueTaskReturningThunk(Continuation cont
};
continuation.Next = finalContinuation;
- while (true)
- {
- Continuation headContinuation = UnlinkHeadContinuation(out var awaitableProxy);
- await awaitableProxy;
- Continuation? finalResult = DispatchContinuations(headContinuation);
- if (finalResult != null)
- {
- Debug.Assert(finalResult == finalContinuation);
- return;
- }
- }
+ ThunkTask result = new();
+ result.HandleSuspended();
+ return result;
}
- // Return a continuation object if that is the one which has the final
- // result of the Task, if the real output of the series of continuations was
- // an exception, it is allowed to propagate out.
- // OR
- // return NULL to indicate that this isn't yet done.
- private static unsafe Continuation? DispatchContinuations(Continuation? continuation)
+ private static ValueTask FinalizeValueTaskReturningThunk(Continuation continuation)
{
- Debug.Assert(continuation != null);
-
- while (true)
- {
- Continuation? newContinuation;
- try
- {
- newContinuation = continuation.Resume(continuation);
- }
- catch (Exception ex)
- {
- continuation = UnwindToPossibleHandler(continuation);
- if (continuation.Resume == null)
- {
- throw;
- }
-
- continuation.GCData![(continuation.Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_RESULT_IN_GCDATA) != 0 ? 1 : 0] = ex;
- continue;
- }
-
- if (newContinuation != null)
- {
- newContinuation.Next = continuation.Next;
- return null;
- }
+ // We only come to these methods in the expensive case (already
+ // suspended), so ValueTask optimization here is not relevant.
+ return new ValueTask(FinalizeTaskReturningThunk(continuation));
+ }
- continuation = continuation.Next;
- Debug.Assert(continuation != null);
+ private static ValueTask FinalizeValueTaskReturningThunk(Continuation continuation)
+ {
+ return new ValueTask(FinalizeTaskReturningThunk(continuation));
+ }
- if (continuation.Resume == null)
- {
- return continuation; // Return the result containing Continuation
- }
- }
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private static ExecutionContext? CaptureExecutionContext()
+ {
+ return Thread.CurrentThreadAssumedInitialized._executionContext;
}
- private static Continuation UnwindToPossibleHandler(Continuation continuation)
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private static void RestoreExecutionContext(ExecutionContext? previousExecCtx)
{
- while (true)
+ Thread thread = Thread.CurrentThreadAssumedInitialized;
+ ExecutionContext? currentExecCtx = thread._executionContext;
+ if (previousExecCtx != currentExecCtx)
{
- Debug.Assert(continuation.Next != null);
- continuation = continuation.Next;
- if ((continuation.Flags & CorInfoContinuationFlags.CORINFO_CONTINUATION_NEEDS_EXCEPTION) != 0)
- return continuation;
+ ExecutionContext.RestoreChangedContextToThread(thread, previousExecCtx, currentExecCtx);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- private static ExecutionContext? CaptureExecutionContext()
+ private static void CaptureContexts(out ExecutionContext? execCtx, out SynchronizationContext? syncCtx)
{
- return Thread.CurrentThreadAssumedInitialized._executionContext;
+ Thread thread = Thread.CurrentThreadAssumedInitialized;
+ execCtx = thread._executionContext;
+ syncCtx = thread._synchronizationContext;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- private static void RestoreExecutionContext(ExecutionContext? previousExecutionCtx)
+ private static void RestoreContexts(bool suspended, ExecutionContext? previousExecCtx, SynchronizationContext? previousSyncCtx)
{
Thread thread = Thread.CurrentThreadAssumedInitialized;
- ExecutionContext? currentExecutionCtx = thread._executionContext;
- if (previousExecutionCtx != currentExecutionCtx)
+ if (!suspended && previousSyncCtx != thread._synchronizationContext)
{
- ExecutionContext.RestoreChangedContextToThread(thread, previousExecutionCtx, currentExecutionCtx);
+ thread._synchronizationContext = previousSyncCtx;
}
+
+ ExecutionContext? currentExecCtx = thread._executionContext;
+ if (previousExecCtx != currentExecCtx)
+ {
+ ExecutionContext.RestoreChangedContextToThread(thread, previousExecCtx, currentExecCtx);
+ }
+ }
+
+ private static void CaptureContinuationContext(SynchronizationContext syncCtx, ref object context, ref CorInfoContinuationFlags flags)
+ {
+ if (syncCtx != null && syncCtx.GetType() != typeof(SynchronizationContext))
+ {
+ flags |= CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_SYNCHRONIZATION_CONTEXT;
+ context = syncCtx;
+ return;
+ }
+
+ TaskScheduler? sched = TaskScheduler.InternalCurrent;
+ if (sched != null && sched != TaskScheduler.Default)
+ {
+ flags |= CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_CAPTURED_TASK_SCHEDULER;
+ context = sched;
+ return;
+ }
+
+ flags |= CorInfoContinuationFlags.CORINFO_CONTINUATION_CONTINUE_ON_THREAD_POOL;
}
}
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs
index 91582d975d9ee0..95ceb043c386cc 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs
@@ -488,15 +488,41 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size)
private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size);
[MethodImpl(MethodImplOptions.InternalCall)]
- private static extern IntPtr AllocTailCallArgBufferWorker(int size, IntPtr gcDesc);
+ private static extern unsafe TailCallArgBuffer* GetTailCallArgBuffer();
- private static IntPtr AllocTailCallArgBuffer(int size, IntPtr gcDesc)
+ [LibraryImport(QCall, EntryPoint = "TailCallHelp_AllocTailCallArgBufferInternal")]
+ private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size);
+
+ private const int TAILCALLARGBUFFER_ACTIVE = 0;
+ // private const int TAILCALLARGBUFFER_INSTARG_ONLY = 1;
+ private const int TAILCALLARGBUFFER_INACTIVE = 2;
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)] // To allow unrolling of Span.Clear
+ private static unsafe TailCallArgBuffer* AllocTailCallArgBuffer(int size, IntPtr gcDesc)
{
- IntPtr buffer = AllocTailCallArgBufferWorker(size, gcDesc);
- if (buffer == IntPtr.Zero)
+ TailCallArgBuffer* buffer = GetTailCallArgBuffer();
+ if (buffer != null && buffer->Size >= size)
+ {
+ buffer->State = TAILCALLARGBUFFER_INACTIVE;
+ }
+ else
{
- throw new OutOfMemoryException();
+ buffer = AllocTailCallArgBufferWorker(size);
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ static TailCallArgBuffer* AllocTailCallArgBufferWorker(int size) => AllocTailCallArgBufferInternal(size);
}
+ Debug.Assert(buffer != null);
+ Debug.Assert(buffer->Size >= size);
+ Debug.Assert(buffer->State == TAILCALLARGBUFFER_INACTIVE);
+
+ buffer->GCDesc = gcDesc;
+
+ new Span(buffer + 1, size - sizeof(TailCallArgBuffer)).Clear();
+
+ // The buffer is now ready to be used.
+ buffer->State = TAILCALLARGBUFFER_ACTIVE;
+
return buffer;
}
@@ -506,7 +532,7 @@ private static IntPtr AllocTailCallArgBuffer(int size, IntPtr gcDesc)
[StackTraceHidden]
private static unsafe void DispatchTailCalls(
IntPtr callersRetAddrSlot,
- delegate* callTarget,
+ delegate* callTarget,
ref byte retVal)
{
IntPtr callersRetAddr;
@@ -537,11 +563,8 @@ private static unsafe void DispatchTailCalls(
{
tls->Frame = prevFrame;
- // If the arg buffer is reporting inst argument, it is safe to abandon it now
- if (tls->ArgBuffer != IntPtr.Zero && *(int*)tls->ArgBuffer == 1 /* TAILCALLARGBUFFER_INSTARG_ONLY */)
- {
- *(int*)tls->ArgBuffer = 2 /* TAILCALLARGBUFFER_ABANDONED */;
- }
+ // If the arg buffer is reporting inst argument (TAILCALLARGBUFFER_INSTARG_ONLY), it is safe to abandon it now.
+ tls->ArgBuffer->State = TAILCALLARGBUFFER_INACTIVE;
}
}
@@ -1217,13 +1240,22 @@ private static bool CanCastToWorker(TypeHandle srcTH, TypeHandle destTH, bool nu
internal unsafe struct PortableTailCallFrame
{
public IntPtr TailCallAwareReturnAddress;
- public delegate* NextCall;
+ public delegate* NextCall;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct TailCallArgBuffer
+ {
+ public int State;
+ public int Size;
+ public IntPtr GCDesc;
+ // Args
}
[StructLayout(LayoutKind.Sequential)]
internal unsafe struct TailCallTls
{
public PortableTailCallFrame* Frame;
- public IntPtr ArgBuffer;
+ public TailCallArgBuffer* ArgBuffer;
}
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/AsmOffsets.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/AsmOffsets.cs
index df3da7a876b787..86cb928e36e89d 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/AsmOffsets.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/AsmOffsets.cs
@@ -51,9 +51,9 @@ class AsmOffsets
public const int OFFSETOF__REGDISPLAY__SP = 0xba8;
public const int OFFSETOF__REGDISPLAY__ControlPC = 0xbb0;
#elif TARGET_WASM
- public const int SIZEOF__REGDISPLAY = 0x3c;
- public const int OFFSETOF__REGDISPLAY__SP = 0x34;
- public const int OFFSETOF__REGDISPLAY__ControlPC = 0x38;
+ public const int SIZEOF__REGDISPLAY = 0x38;
+ public const int OFFSETOF__REGDISPLAY__SP = 0x30;
+ public const int OFFSETOF__REGDISPLAY__ControlPC = 0x34;
#endif
#if TARGET_64BIT
@@ -73,9 +73,14 @@ class AsmOffsets
public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x3d0;
#else // TARGET_64BIT
public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
+#if FEATURE_INTERPRETER
+ public const int SIZEOF__StackFrameIterator = 0xdc;
+ public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xd8;
+#else
public const int SIZEOF__StackFrameIterator = 0xcc;
- public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0xba;
public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xc8;
+#endif
+ public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0xba;
#endif // TARGET_64BIT
#else // DEBUG
@@ -117,9 +122,9 @@ class AsmOffsets
public const int OFFSETOF__REGDISPLAY__SP = 0xba0;
public const int OFFSETOF__REGDISPLAY__ControlPC = 0xba8;
#elif TARGET_WASM
- public const int SIZEOF__REGDISPLAY = 0x3c;
- public const int OFFSETOF__REGDISPLAY__SP = 0x34;
- public const int OFFSETOF__REGDISPLAY__ControlPC = 0x38;
+ public const int SIZEOF__REGDISPLAY = 0x34;
+ public const int OFFSETOF__REGDISPLAY__SP = 0x2c;
+ public const int OFFSETOF__REGDISPLAY__ControlPC = 0x30;
#endif
#if TARGET_64BIT
@@ -139,9 +144,14 @@ class AsmOffsets
public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x3c8;
#else // TARGET_64BIT
public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
+#if FEATURE_INTERPRETER
+ public const int SIZEOF__StackFrameIterator = 0xd4;
+ public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xd0;
+#else
public const int SIZEOF__StackFrameIterator = 0xc4;
- public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0xb2;
public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xc0;
+#endif
+ public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0xb2;
#endif // TARGET_64BIT
#endif // DEBUG
@@ -167,7 +177,7 @@ class AsmOffsets
#elif TARGET_LOONGARCH64
public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x520;
#elif TARGET_WASM
- public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x08;
+ public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x04;
#endif
#if TARGET_AMD64
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs
index 0314219f14ce97..260534b1ce799a 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs
@@ -30,7 +30,7 @@ internal static bool IsInterfaceImplemented(IDynamicInterfaceCastable castable,
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, castable.GetType(), interfaceType));
RuntimeType implType = handle.GetRuntimeType();
- if (!implType.IsInterface)
+ if (!implType.IsActualInterface)
throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_NotInterface, implType.ToString()));
if (!implType.IsDefined(typeof(DynamicInterfaceCastableImplementationAttribute), inherit: false))
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs
similarity index 81%
rename from src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.cs
rename to src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs
index 42f3b023a4803c..357e3575812e5c 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs
@@ -12,39 +12,24 @@ public static partial class JavaMarshal
{
public static unsafe void Initialize(delegate* unmanaged markCrossReferences)
{
-#if NATIVEAOT
- throw new NotImplementedException();
-#elif FEATURE_JAVAMARSHAL
ArgumentNullException.ThrowIfNull(markCrossReferences);
if (!InitializeInternal((IntPtr)markCrossReferences))
{
throw new InvalidOperationException(SR.InvalidOperation_ReinitializeJavaMarshal);
}
-#else
- throw new PlatformNotSupportedException();
-#endif
}
public static unsafe GCHandle CreateReferenceTrackingHandle(object obj, void* context)
{
-#if NATIVEAOT
- throw new NotImplementedException();
-#elif FEATURE_JAVAMARSHAL
ArgumentNullException.ThrowIfNull(obj);
IntPtr handle = CreateReferenceTrackingHandleInternal(ObjectHandleOnStack.Create(ref obj), context);
return GCHandle.FromIntPtr(handle);
-#else
- throw new PlatformNotSupportedException();
-#endif
}
public static unsafe void* GetContext(GCHandle obj)
{
-#if NATIVEAOT
- throw new NotImplementedException();
-#elif FEATURE_JAVAMARSHAL
IntPtr handle = GCHandle.ToIntPtr(obj);
if (handle == IntPtr.Zero
|| !GetContextInternal(handle, out void* context))
@@ -53,18 +38,12 @@ public static unsafe GCHandle CreateReferenceTrackingHandle(object obj, void* co
}
return context;
-#else
- throw new PlatformNotSupportedException();
-#endif
}
public static unsafe void FinishCrossReferenceProcessing(
MarkCrossReferencesArgs* crossReferences,
ReadOnlySpan unreachableObjectHandles)
{
-#if NATIVEAOT
- throw new NotImplementedException();
-#elif FEATURE_JAVAMARSHAL
fixed (GCHandle* pHandles = unreachableObjectHandles)
{
FinishCrossReferenceProcessing(
@@ -72,12 +51,8 @@ public static unsafe void FinishCrossReferenceProcessing(
(nuint)unreachableObjectHandles.Length,
pHandles);
}
-#else
- throw new PlatformNotSupportedException();
-#endif
}
-#if FEATURE_JAVAMARSHAL && !NATIVEAOT
[LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_Initialize")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool InitializeInternal(IntPtr callback);
@@ -92,6 +67,5 @@ public static unsafe void FinishCrossReferenceProcessing(
[SuppressGCTransition]
[return: MarshalAs(UnmanagedType.Bool)]
private static unsafe partial bool GetContextInternal(IntPtr handle, out void* context);
-#endif
}
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs
index bd2a5414a719aa..a0a16ed52480c7 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs
@@ -110,9 +110,9 @@ internal Assembly LoadFromInMemoryModule(IntPtr moduleHandle)
// This method is invoked by the VM to resolve a satellite assembly reference
// after trying assembly resolution via Load override without success.
- private static RuntimeAssembly? ResolveSatelliteAssembly(IntPtr gchManagedAssemblyLoadContext, AssemblyName assemblyName)
+ private static RuntimeAssembly? ResolveSatelliteAssembly(IntPtr gchAssemblyLoadContext, AssemblyName assemblyName)
{
- AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target)!;
+ AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!;
// Invoke the ResolveSatelliteAssembly method
return context.ResolveSatelliteAssembly(assemblyName);
@@ -120,25 +120,25 @@ internal Assembly LoadFromInMemoryModule(IntPtr moduleHandle)
// This method is invoked by the VM when using the host-provided assembly load context
// implementation.
- private static IntPtr ResolveUnmanagedDll(string unmanagedDllName, IntPtr gchManagedAssemblyLoadContext)
+ private static IntPtr ResolveUnmanagedDll(string unmanagedDllName, IntPtr gchAssemblyLoadContext)
{
- AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target)!;
+ AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!;
return context.LoadUnmanagedDll(unmanagedDllName);
}
// This method is invoked by the VM to resolve a native library using the ResolvingUnmanagedDll event
// after trying all other means of resolution.
- private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchManagedAssemblyLoadContext)
+ private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchAssemblyLoadContext)
{
- AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target)!;
+ AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!;
return context.GetResolvedUnmanagedDll(assembly, unmanagedDllName);
}
// This method is invoked by the VM to resolve an assembly reference using the Resolving event
// after trying assembly resolution via Load override and TPA load context without success.
- private static RuntimeAssembly? ResolveUsingResolvingEvent(IntPtr gchManagedAssemblyLoadContext, AssemblyName assemblyName)
+ private static RuntimeAssembly? ResolveUsingResolvingEvent(IntPtr gchAssemblyLoadContext, AssemblyName assemblyName)
{
- AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target)!;
+ AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!;
// Invoke the AssemblyResolve event callbacks if wired up
return context.ResolveUsingEvent(assemblyName);
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
index b8ae179ff25ce5..2bc71d3dfbd59f 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -1048,7 +1048,7 @@ internal bool IsNullHandle()
public IntPtr GetFunctionPointer()
{
- IntPtr ptr = GetFunctionPointer(EnsureNonNullMethodInfo(m_value!).Value);
+ IntPtr ptr = GetFunctionPointer(EnsureNonNullMethodInfo(m_value).Value);
GC.KeepAlive(m_value);
return ptr;
}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
index 5e872581a02f60..cc4ae643e1beb3 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -25,7 +25,7 @@ internal enum TypeNameFormatFlags
FormatFullInst = 0x00000002, // Include namespace and assembly in generic types (regardless of other flag settings)
FormatAssembly = 0x00000004, // Include assembly display name in type names
FormatSignature = 0x00000008, // Include signature in method names
- FormatNoVersion = 0x00000010, // Suppress version and culture information in all assembly names
+ // unused = 0x00000010,
#if DEBUG
FormatDebug = 0x00000020, // For debug printing of types only
#endif
@@ -34,13 +34,6 @@ internal enum TypeNameFormatFlags
FormatGenericParam = 0x00000100, // Use !name and !!name for generic type and method parameters
}
- internal enum TypeNameKind
- {
- Name,
- ToString,
- FullName,
- }
-
internal sealed partial class RuntimeType : TypeInfo, ICloneable
{
#region Definitions
@@ -567,7 +560,7 @@ private void MergeWithGlobalList(T[] list)
cachedMembers = cachedMembers2;
}
- Debug.Assert(cachedMembers![freeSlotIndex] == null);
+ Debug.Assert(cachedMembers[freeSlotIndex] == null);
Volatile.Write(ref cachedMembers[freeSlotIndex], newMemberInfo); // value may be read outside of lock
freeSlotIndex++;
}
@@ -586,7 +579,7 @@ private unsafe RuntimeMethodInfo[] PopulateMethods(Filter filter)
RuntimeType declaringType = ReflectedType;
Debug.Assert(declaringType != null);
- if (declaringType.IsInterface)
+ if (declaringType.IsActualInterface)
{
#region IsInterface
@@ -1005,7 +998,7 @@ private RuntimeType[] PopulateInterfaces(Filter filter)
continue;
}
- Debug.Assert(interfaceType.IsInterface);
+ Debug.Assert(interfaceType.IsActualInterface);
list.Add(interfaceType);
}
@@ -1035,7 +1028,7 @@ private RuntimeType[] PopulateInterfaces(Filter filter)
for (int i = 0; i < constraints.Length; i++)
{
RuntimeType constraint = (RuntimeType)constraints[i];
- if (constraint.IsInterface)
+ if (constraint.IsActualInterface)
al.Add(constraint);
Type[] temp = constraint.GetInterfaces();
@@ -1120,7 +1113,7 @@ private RuntimeEventInfo[] PopulateEvents(Filter filter)
RuntimeType declaringType = ReflectedType;
ListBuilder list = default;
- if (!declaringType.IsInterface)
+ if (!declaringType.IsActualInterface)
{
while (RuntimeTypeHandle.IsGenericVariable(declaringType))
declaringType = declaringType.GetBaseType()!;
@@ -1213,7 +1206,7 @@ private RuntimePropertyInfo[] PopulateProperties(Filter filter)
ListBuilder list = default;
- if (!declaringType.IsInterface)
+ if (!declaringType.IsActualInterface)
{
while (RuntimeTypeHandle.IsGenericVariable(declaringType))
declaringType = declaringType.GetBaseType()!;
@@ -1265,8 +1258,8 @@ private void PopulateProperties(
int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(declaringType);
- Debug.Assert((declaringType.IsInterface && isInterface && csPropertyInfos == null) ||
- (!declaringType.IsInterface && !isInterface && usedSlots.Length >= numVirtuals));
+ Debug.Assert((declaringType.IsActualInterface && isInterface && csPropertyInfos == null) ||
+ (!declaringType.IsActualInterface && !isInterface && usedSlots.Length >= numVirtuals));
for (int i = 0; i < tkProperties.Length; i++)
{
@@ -1357,7 +1350,7 @@ private void PopulateProperties(
for (int j = 0; j < list.Count; j++)
{
- if (propertyInfo.EqualsSig(list[j]!))
+ if (propertyInfo.EqualsSig(list[j]))
{
duplicate = true;
break;
@@ -1408,7 +1401,8 @@ internal T[] GetMemberList(MemberListType listType, string? name, CacheType cach
private RuntimeType? m_enclosingType;
private TypeCode m_typeCode;
private string? m_name;
- private string? m_fullname;
+ private string? m_fullName;
+ private string? m_assemblyQualifiedName;
private string? m_toString;
private string? m_namespace;
private readonly bool m_isGlobal;
@@ -1438,8 +1432,10 @@ internal RuntimeTypeCache(RuntimeType runtimeType)
#endregion
#region Private Members
- private string ConstructName([NotNull] ref string? name, TypeNameFormatFlags formatFlags) =>
- name ??= new RuntimeTypeHandle(m_runtimeType).ConstructName(formatFlags);
+ // This is the slow path for construction. Mark it to avoid inlining it into the caller.
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private string ConstructName(ref string? name, TypeNameFormatFlags formatFlags) =>
+ name = new RuntimeTypeHandle(m_runtimeType).ConstructName(formatFlags);
private T[] GetMemberList(ref MemberInfoCache? m_cache, MemberListType listType, string? name, CacheType cacheType)
where T : MemberInfo
@@ -1494,52 +1490,32 @@ internal Type[] FunctionPointerReturnAndParameterTypes
}
}
- internal string? GetName(TypeNameKind kind)
- {
- switch (kind)
- {
- case TypeNameKind.Name:
- // No namespace, full instantiation, and assembly.
- return ConstructName(ref m_name, TypeNameFormatFlags.FormatBasic);
-
- case TypeNameKind.FullName:
- // We exclude the types that contain generic parameters because their names cannot be roundtripped.
- // We allow generic type definitions (and their refs, ptrs, and arrays) because their names can be roundtriped.
- // Theoretically generic types instantiated with generic type definitions can be roundtripped, e.g. List`1.
- // But these kind of types are useless, rare, and hard to identity. We would need to recursively examine all the
- // generic arguments with the same criteria. We will exclude them unless we see a real user scenario.
- if (!m_runtimeType.GetRootElementType().IsGenericTypeDefinition && m_runtimeType.ContainsGenericParameters)
- return null;
-
- // Exclude function pointer; it requires a grammar update and parsing support for Type.GetType() and friends.
- // See https://learn.microsoft.com/dotnet/framework/reflection-and-codedom/specifying-fully-qualified-type-names.
- if (m_runtimeType.IsFunctionPointer)
- return null;
-
- // No assembly.
- return ConstructName(ref m_fullname, TypeNameFormatFlags.FormatNamespace | TypeNameFormatFlags.FormatFullInst);
-
- case TypeNameKind.ToString:
- // No full instantiation and assembly.
- return ConstructName(ref m_toString, TypeNameFormatFlags.FormatNamespace);
-
- default:
- throw new InvalidOperationException();
- }
- }
+ // No namespace, full instantiation, and assembly.
+ internal string GetName() => m_name ?? ConstructName(ref m_name, TypeNameFormatFlags.FormatBasic)!;
+
+ // No assembly.
+ internal string? GetFullName() => m_fullName ??
+ (IsFullNameRoundtripCompatible(m_runtimeType)
+ ? ConstructName(ref m_fullName, TypeNameFormatFlags.FormatNamespace | TypeNameFormatFlags.FormatFullInst)
+ : null);
+
+ // No full instantiation and assembly.
+ internal string GetToString() => m_toString ?? ConstructName(ref m_toString, TypeNameFormatFlags.FormatNamespace)!;
- internal string? GetNameSpace()
+ internal string? GetAssemblyQualifiedName() => m_assemblyQualifiedName ??
+ (IsFullNameRoundtripCompatible(m_runtimeType)
+ ? ConstructName(ref m_assemblyQualifiedName, TypeNameFormatFlags.FormatNamespace | TypeNameFormatFlags.FormatFullInst | TypeNameFormatFlags.FormatAssembly)
+ : null);
+
+ internal string? GetNamespace()
{
// @Optimization - Use ConstructName to populate m_namespace
if (m_namespace == null)
{
- Type type = m_runtimeType;
-
+ Type type = m_runtimeType.GetRootElementType();
if (type.IsFunctionPointer)
return null;
- type = type.GetRootElementType();
-
while (type.IsNested)
type = type.DeclaringType!;
@@ -2721,7 +2697,7 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
TypeHandle.VerifyInterfaceIsImplemented(ifaceRtTypeHandle);
Debug.Assert(interfaceType.IsInterface); // VerifyInterfaceIsImplemented enforces this invariant
- Debug.Assert(!IsInterface); // VerifyInterfaceIsImplemented enforces this invariant
+ Debug.Assert(!IsActualInterface); // VerifyInterfaceIsImplemented enforces this invariant
// SZArrays implement the methods on IList`1, IEnumerable`1, and ICollection`1 with
// SZArrayHelper and some runtime magic. We don't have accurate interface maps for them.
@@ -2736,24 +2712,34 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
im.InterfaceMethods = new MethodInfo[ifaceVirtualMethodCount];
im.TargetMethods = new MethodInfo[ifaceVirtualMethodCount];
+ int actualCount = 0;
for (int i = 0; i < ifaceVirtualMethodCount; i++)
{
RuntimeMethodHandleInternal ifaceRtMethodHandle = RuntimeTypeHandle.GetMethodAt(ifaceRtType, i);
+ // GetMethodAt may return null handle for methods that do not exist or are not supposed
+ // to be seen in reflection. One example is async variant methods.
+ // We do not record mapping for interface methods that do not exist.
+ if (ifaceRtMethodHandle.IsNullHandle())
+ continue;
+
// GetMethodBase will convert this to the instantiating/unboxing stub if necessary
MethodBase ifaceMethodBase = GetMethodBase(ifaceRtType, ifaceRtMethodHandle)!;
Debug.Assert(ifaceMethodBase is RuntimeMethodInfo);
- im.InterfaceMethods[i] = (MethodInfo)ifaceMethodBase;
+ im.InterfaceMethods[actualCount] = (MethodInfo)ifaceMethodBase;
// If the impl is null, then virtual stub dispatch is active.
RuntimeMethodHandleInternal classRtMethodHandle = TypeHandle.GetInterfaceMethodImplementation(ifaceRtTypeHandle, ifaceRtMethodHandle);
if (classRtMethodHandle.IsNullHandle())
+ {
+ actualCount++;
continue;
+ }
// If we resolved to an interface method, use the interface type as reflected type. Otherwise use `this`.
RuntimeType reflectedType = RuntimeMethodHandle.GetDeclaringType(classRtMethodHandle);
- if (!reflectedType.IsInterface)
+ if (!reflectedType.IsActualInterface)
reflectedType = this;
// GetMethodBase will convert this to the instantiating/unboxing stub if necessary
@@ -2764,10 +2750,16 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
// the TargetMethod provided to us by runtime internals may be a generic method instance,
// potentially with invalid arguments. TargetMethods in the InterfaceMap should never be
// instances, only definitions.
- im.TargetMethods[i] = (targetMethod is { IsGenericMethod: true, IsGenericMethodDefinition: false })
+ im.TargetMethods[actualCount++] = (targetMethod is { IsGenericMethod: true, IsGenericMethodDefinition: false })
? targetMethod.GetGenericMethodDefinition() : targetMethod!;
}
+ if (actualCount != ifaceVirtualMethodCount)
+ {
+ Array.Resize(ref im.InterfaceMethods, actualCount);
+ Array.Resize(ref im.TargetMethods, actualCount);
+ }
+
return im;
}
#endregion
@@ -3318,28 +3310,15 @@ public override bool IsEquivalentTo([NotNullWhen(true)] Type? other)
#region Name
- public override string? FullName => GetCachedName(TypeNameKind.FullName);
-
- public override string? AssemblyQualifiedName
- {
- get
- {
- string? fullname = FullName;
-
- // FullName is null if this type contains generic parameters but is not a generic type definition
- // or if it is a function pointer.
- if (fullname == null)
- return null;
+ public override string? FullName => Cache.GetFullName();
- return Assembly.CreateQualifiedName(Assembly.FullName, fullname);
- }
- }
+ public override string? AssemblyQualifiedName => Cache.GetAssemblyQualifiedName();
public override string? Namespace
{
get
{
- string? ns = Cache.GetNameSpace();
+ string? ns = Cache.GetNamespace();
if (string.IsNullOrEmpty(ns))
{
return null;
@@ -3453,7 +3432,7 @@ internal unsafe bool IsActualEnum
}
}
- internal new unsafe bool IsInterface
+ internal unsafe bool IsActualInterface
{
get
{
@@ -3811,17 +3790,11 @@ public override Type GetFunctionPointerReturnType()
#endregion
- public override string ToString() => GetCachedName(TypeNameKind.ToString)!;
+ public override string ToString() => Cache.GetToString();
#region MemberInfo Overrides
- public override string Name => GetCachedName(TypeNameKind.Name)!;
-
- // This method looks like an attractive inline but expands to two calls,
- // neither of which can be inlined or optimized further. So block it
- // from inlining.
- [MethodImpl(MethodImplOptions.NoInlining)]
- private string? GetCachedName(TypeNameKind kind) => Cache.GetName(kind);
+ public override string Name => Cache.GetName();
public override Type? DeclaringType => Cache.GetEnclosingType();
@@ -3974,6 +3947,11 @@ internal object GetUninitializedObject()
throw new MissingMethodException(SR.Format(SR.Arg_NoDefCTor, this));
}
+ if (IsByRefLike)
+ {
+ throw new NotSupportedException(SR.NotSupported_ByRefLike);
+ }
+
// Compat: allocation always takes place outside the try block so that OOMs
// bubble up to the caller; the ctor invocation is within the try block so
// that it can be wrapped in TIE if needed.
@@ -3996,6 +3974,8 @@ internal object GetUninitializedObject()
[DebuggerHidden]
internal object? CreateInstanceOfT()
{
+ Debug.Assert(!IsValueType);
+
ActivatorCache cache = GetOrCreateCacheEntry();
if (!cache.CtorIsPublic)
diff --git a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs
index e66db58ba95f52..a2c9f4f6e4e98c 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs
@@ -25,10 +25,10 @@ internal static unsafe string StrCns(uint rid, IntPtr scopeHandle)
}
[MethodImpl(MethodImplOptions.InternalCall)]
- internal static extern unsafe string FastAllocateString(MethodTable *pMT, int length);
+ internal static extern unsafe string FastAllocateString(MethodTable *pMT, nint length);
[DebuggerHidden]
- internal static unsafe string FastAllocateString(int length)
+ internal static unsafe string FastAllocateString(nint length)
{
return FastAllocateString(TypeHandle.TypeHandleOf().AsMethodTable(), length);
}
@@ -40,7 +40,7 @@ public static string Intern(string str)
{
ArgumentNullException.ThrowIfNull(str);
Intern(new StringHandleOnStack(ref str!));
- return str!;
+ return str;
}
[LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_IsInterned")]
diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs
index a6494bf27883e7..61e71adcff477a 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs
@@ -944,7 +944,7 @@ private unsafe IntPtr ConvertArrayToNative(object pManagedHome, int dwFlags)
}
default:
- throw new ArgumentException(SR.Arg_NDirectBadObject);
+ throw new ArgumentException(SR.Arg_PInvokeBadObject);
}
// marshal the object as C-style array (UnmanagedType.LPArray)
@@ -1151,7 +1151,7 @@ internal IntPtr ConvertToNative(object pManagedHome, int dwFlags)
else
{
// this type is not supported for AsAny marshaling
- throw new ArgumentException(SR.Arg_NDirectBadObject);
+ throw new ArgumentException(SR.Arg_PInvokeBadObject);
}
}
@@ -1351,26 +1351,20 @@ internal static void DestroyCleanupList(ref CleanupWorkListElement? pCleanupWork
internal static Exception GetHRExceptionObject(int hr)
{
- Exception? ex = null;
- GetHRExceptionObject(hr, ObjectHandleOnStack.Create(ref ex));
- ex!.InternalPreserveStackTrace();
- return ex!;
+ Exception ex = Marshal.GetExceptionForHR(hr)!;
+ ex.InternalPreserveStackTrace();
+ return ex;
}
- [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetHRExceptionObject")]
- private static partial void GetHRExceptionObject(int hr, ObjectHandleOnStack throwable);
-
#if FEATURE_COMINTEROP
- internal static Exception GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object pThis)
+ internal static Exception GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, IntPtr pUnk)
{
- Exception? ex = null;
- GetCOMHRExceptionObject(hr, pCPCMD, ObjectHandleOnStack.Create(ref pThis), ObjectHandleOnStack.Create(ref ex));
- ex!.InternalPreserveStackTrace();
- return ex!;
+ RuntimeMethodHandle handle = RuntimeMethodHandle.FromIntPtr(pCPCMD);
+ RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(handle.GetMethodInfo());
+ Exception ex = Marshal.GetExceptionForHR(hr, declaringType.GUID, pUnk)!;
+ ex.InternalPreserveStackTrace();
+ return ex;
}
-
- [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMHRExceptionObject")]
- private static partial void GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, ObjectHandleOnStack pThis, ObjectHandleOnStack throwable);
#endif // FEATURE_COMINTEROP
[ThreadStatic]
@@ -1583,8 +1577,7 @@ internal static void ValidateObject(object obj, IntPtr pMD)
internal static partial void ValidateByref(IntPtr byref, IntPtr pMD); // the byref is pinned so we can safely "cast" it to IntPtr
[Intrinsic]
- [MethodImpl(MethodImplOptions.InternalCall)]
- internal static extern IntPtr GetStubContext();
+ internal static IntPtr GetStubContext() => throw new UnreachableException(); // Unconditionally expanded intrinsic
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void MulticastDebuggerTraceHelper(object o, int count)
@@ -1596,11 +1589,10 @@ internal static void MulticastDebuggerTraceHelper(object o, int count)
private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count);
[Intrinsic]
- [MethodImpl(MethodImplOptions.InternalCall)]
- internal static extern IntPtr NextCallReturnAddress();
+ internal static IntPtr NextCallReturnAddress() => throw new UnreachableException(); // Unconditionally expanded intrinsic
[Intrinsic]
- internal static Continuation? AsyncCallContinuation() => null;
+ internal static Continuation? AsyncCallContinuation() => throw new UnreachableException(); // Unconditionally expanded intrinsic
} // class StubHelpers
#if FEATURE_COMINTEROP
diff --git a/src/coreclr/binder/assemblybindercommon.cpp b/src/coreclr/binder/assemblybindercommon.cpp
index 4ae509125ecb52..6321e50630bc45 100644
--- a/src/coreclr/binder/assemblybindercommon.cpp
+++ b/src/coreclr/binder/assemblybindercommon.cpp
@@ -27,7 +27,7 @@
#if !defined(DACCESS_COMPILE)
#include "defaultassemblybinder.h"
// Helper function in the VM, invoked by the Binder, to invoke the host assembly resolver
-extern HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pManagedAssemblyLoadContextToBindWithin,
+extern HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pAssemblyLoadContextToBindWithin,
BINDER_SPACE::AssemblyName *pAssemblyName,
DefaultAssemblyBinder *pDefaultBinder,
AssemblyBinder *pBinder,
@@ -1147,7 +1147,7 @@ namespace BINDER_SPACE
#if !defined(DACCESS_COMPILE)
-HRESULT AssemblyBinderCommon::BindUsingHostAssemblyResolver(/* in */ INT_PTR pManagedAssemblyLoadContextToBindWithin,
+HRESULT AssemblyBinderCommon::BindUsingHostAssemblyResolver(/* in */ INT_PTR pAssemblyLoadContextToBindWithin,
/* in */ AssemblyName *pAssemblyName,
/* in */ DefaultAssemblyBinder *pDefaultBinder,
/* in */ AssemblyBinder *pBinder,
@@ -1155,11 +1155,11 @@ HRESULT AssemblyBinderCommon::BindUsingHostAssemblyResolver(/* in */ INT_PTR pMa
{
HRESULT hr = E_FAIL;
- _ASSERTE(pManagedAssemblyLoadContextToBindWithin != (INT_PTR)NULL);
+ _ASSERTE(pAssemblyLoadContextToBindWithin != (INT_PTR)NULL);
// RuntimeInvokeHostAssemblyResolver will perform steps 2-4 of CustomAssemblyBinder::BindAssemblyByName.
BINDER_SPACE::Assembly *pLoadedAssembly = NULL;
- hr = RuntimeInvokeHostAssemblyResolver(pManagedAssemblyLoadContextToBindWithin,
+ hr = RuntimeInvokeHostAssemblyResolver(pAssemblyLoadContextToBindWithin,
pAssemblyName, pDefaultBinder, pBinder, &pLoadedAssembly);
if (SUCCEEDED(hr))
{
@@ -1297,7 +1297,7 @@ HRESULT AssemblyBinderCommon::CreateDefaultBinder(DefaultAssemblyBinder** ppDefa
hr = pApplicationContext->Init();
if (SUCCEEDED(hr))
{
- pBinder->SetManagedAssemblyLoadContext((INT_PTR)NULL);
+ pBinder->SetAssemblyLoadContext((INT_PTR)NULL);
*ppDefaultBinder = pBinder.Extract();
}
}
diff --git a/src/coreclr/binder/customassemblybinder.cpp b/src/coreclr/binder/customassemblybinder.cpp
index 99297c2bd9ce31..950e462d512ae5 100644
--- a/src/coreclr/binder/customassemblybinder.cpp
+++ b/src/coreclr/binder/customassemblybinder.cpp
@@ -72,7 +72,7 @@ HRESULT CustomAssemblyBinder::BindUsingAssemblyName(BINDER_SPACE::AssemblyName*
// of what to do next. The host-overridden binder can either fail the bind or return reference to an existing assembly
// that has been loaded.
//
- hr = AssemblyBinderCommon::BindUsingHostAssemblyResolver(GetManagedAssemblyLoadContext(), pAssemblyName,
+ hr = AssemblyBinderCommon::BindUsingHostAssemblyResolver(GetAssemblyLoadContext(), pAssemblyName,
m_pDefaultBinder, this, &pCoreCLRFoundAssembly);
if (SUCCEEDED(hr))
{
@@ -178,7 +178,7 @@ HRESULT CustomAssemblyBinder::SetupContext(DefaultAssemblyBinder *pDefaultBinder
// Save the reference to the IntPtr for GCHandle for the managed
// AssemblyLoadContext instance
- pBinder->SetManagedAssemblyLoadContext(ptrAssemblyLoadContext);
+ pBinder->SetAssemblyLoadContext(ptrAssemblyLoadContext);
if (pLoaderAllocator != NULL)
{
@@ -247,16 +247,16 @@ CustomAssemblyBinder::CustomAssemblyBinder()
void CustomAssemblyBinder::ReleaseLoadContext()
{
- VERIFY(GetManagedAssemblyLoadContext() != (INT_PTR)NULL);
+ VERIFY(GetAssemblyLoadContext() != (INT_PTR)NULL);
VERIFY(m_ptrManagedStrongAssemblyLoadContext != (INT_PTR)NULL);
// This method is called to release the weak and strong handles on the managed AssemblyLoadContext
// once the Unloading event has been fired
- OBJECTHANDLE handle = reinterpret_cast(GetManagedAssemblyLoadContext());
+ OBJECTHANDLE handle = reinterpret_cast(GetAssemblyLoadContext());
DestroyLongWeakHandle(handle);
handle = reinterpret_cast(m_ptrManagedStrongAssemblyLoadContext);
DestroyHandle(handle);
- SetManagedAssemblyLoadContext((INT_PTR)NULL);
+ SetAssemblyLoadContext((INT_PTR)NULL);
// The AssemblyLoaderAllocator is in a process of shutdown and should not be used
// after this point.
diff --git a/src/coreclr/binder/defaultassemblybinder.cpp b/src/coreclr/binder/defaultassemblybinder.cpp
index 54a70e51f05ece..9900da40a7d263 100644
--- a/src/coreclr/binder/defaultassemblybinder.cpp
+++ b/src/coreclr/binder/defaultassemblybinder.cpp
@@ -62,8 +62,8 @@ HRESULT DefaultAssemblyBinder::BindUsingAssemblyName(BINDER_SPACE::AssemblyName
//
// Attempt to resolve the assembly via managed ALC instance. This can either fail the bind or return reference to an existing
// assembly that has been loaded
- INT_PTR pManagedAssemblyLoadContext = GetManagedAssemblyLoadContext();
- if (pManagedAssemblyLoadContext == (INT_PTR)NULL)
+ INT_PTR pAssemblyLoadContext = GetAssemblyLoadContext();
+ if (pAssemblyLoadContext == (INT_PTR)NULL)
{
// For satellite assemblies, the managed ALC has additional resolution logic (defined by the runtime) which
// should be run even if the managed default ALC has not yet been used. (For non-satellite assemblies, any
@@ -77,14 +77,14 @@ HRESULT DefaultAssemblyBinder::BindUsingAssemblyName(BINDER_SPACE::AssemblyName
DECLARE_ARGHOLDER_ARRAY(args, 0);
CALL_MANAGED_METHOD_NORET(args)
- pManagedAssemblyLoadContext = GetManagedAssemblyLoadContext();
- _ASSERTE(pManagedAssemblyLoadContext != (INT_PTR)NULL);
+ pAssemblyLoadContext = GetAssemblyLoadContext();
+ _ASSERTE(pAssemblyLoadContext != (INT_PTR)NULL);
}
}
- if (pManagedAssemblyLoadContext != (INT_PTR)NULL)
+ if (pAssemblyLoadContext != (INT_PTR)NULL)
{
- hr = AssemblyBinderCommon::BindUsingHostAssemblyResolver(pManagedAssemblyLoadContext, pAssemblyName,
+ hr = AssemblyBinderCommon::BindUsingHostAssemblyResolver(pAssemblyLoadContext, pAssemblyName,
NULL, this, &pCoreCLRFoundAssembly);
if (SUCCEEDED(hr))
{
diff --git a/src/coreclr/binder/inc/assemblybindercommon.hpp b/src/coreclr/binder/inc/assemblybindercommon.hpp
index 184d2cd3b8fb86..55049c894f3ba6 100644
--- a/src/coreclr/binder/inc/assemblybindercommon.hpp
+++ b/src/coreclr/binder/inc/assemblybindercommon.hpp
@@ -47,7 +47,7 @@ namespace BINDER_SPACE
/* in */ ProbeExtensionResult probeExtensionResult = ProbeExtensionResult::Invalid());
#if !defined(DACCESS_COMPILE)
- static HRESULT BindUsingHostAssemblyResolver (/* in */ INT_PTR pManagedAssemblyLoadContextToBindWithin,
+ static HRESULT BindUsingHostAssemblyResolver (/* in */ INT_PTR pAssemblyLoadContextToBindWithin,
/* in */ AssemblyName *pAssemblyName,
/* in */ DefaultAssemblyBinder *pDefaultBinder,
/* in */ AssemblyBinder *pBinder,
diff --git a/src/coreclr/clrdatadescriptors.cmake b/src/coreclr/clrdatadescriptors.cmake
new file mode 100644
index 00000000000000..bd3d13836b4f08
--- /dev/null
+++ b/src/coreclr/clrdatadescriptors.cmake
@@ -0,0 +1,90 @@
+# cDAC contract descriptor
+
+function(generate_data_descriptors)
+ set(options EXPORT_VISIBLE)
+ set(oneValueArgs LIBRARY_NAME CONTRACT_FILE CONTRACT_NAME INTERFACE_TARGET)
+ set(multiValueArgs "")
+ cmake_parse_arguments(DATA_DESCRIPTORS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGV})
+
+ # INTERMEDIARY_LIBRARY is used as part of the build and not linked into the final product.
+ set(INTERMEDIARY_LIBRARY ${DATA_DESCRIPTORS_LIBRARY_NAME}_temp)
+ set(LIBRARY ${DATA_DESCRIPTORS_LIBRARY_NAME})
+
+ set(DATA_DESCRIPTOR_SHARED_SOURCE_DIR "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/debug/datadescriptor-shared")
+ set(GENERATED_CDAC_DESCRIPTOR_DIR "${CMAKE_CURRENT_BINARY_DIR}/cdac-${LIBRARY}")
+
+ # configure contract export name
+ set(POINTER_DATA_NAME ${DATA_DESCRIPTORS_CONTRACT_NAME}PointerData)
+ set(CONTRACT_NAME ${DATA_DESCRIPTORS_CONTRACT_NAME})
+ if (DATA_DESCRIPTORS_EXPORT_VISIBLE)
+ set(EXPORT_CONTRACT 1)
+ else()
+ set(EXPORT_CONTRACT 0)
+ endif()
+ configure_file("${DATA_DESCRIPTOR_SHARED_SOURCE_DIR}/contractconfiguration.h.in" "${GENERATED_CDAC_DESCRIPTOR_DIR}/contractconfiguration.h")
+
+ if (NOT CDAC_BUILD_TOOL_BINARY_PATH)
+ # if CDAC_BUILD_TOOL_BINARY_PATH is unspecified (for example for a build without a .NET SDK or msbuild),
+ # link a stub contract descriptor into the runtime
+ add_library_clr(${LIBRARY} OBJECT "${DATA_DESCRIPTOR_SHARED_SOURCE_DIR}/contractdescriptorstub.c")
+ target_include_directories(${LIBRARY} PRIVATE ${GENERATED_CDAC_DESCRIPTOR_DIR})
+ message(STATUS "Using a stub cDAC contract descriptor")
+ else()
+ # generate a contract descriptor using cdac-build-tool from a data descriptor and contract json file
+
+ if(NOT EXISTS "${CDAC_BUILD_TOOL_BINARY_PATH}")
+ message(FATAL_ERROR "${CDAC_BUILD_TOOL_BINARY_PATH} does not exist")
+ endif()
+
+ add_library(${INTERMEDIARY_LIBRARY} OBJECT "${DATA_DESCRIPTOR_SHARED_SOURCE_DIR}/datadescriptor.cpp")
+
+ if(CLR_CMAKE_TARGET_WIN32)
+ # turn off whole program optimization:
+ # 1. it creates object files that cdac-build-tool can't read
+ # 2. we never link INTERMEDIARY_LIBRARY into the final product - it's only job is to be scraped
+ set_target_properties(${INTERMEDIARY_LIBRARY} PROPERTIES
+ INTERPROCEDURAL_OPTIMIZATION_RELEASE OFF
+ INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO OFF)
+ endif()
+
+ # inherit definitions, include directories, and dependencies from the INTERFACE target
+ target_link_libraries(${INTERMEDIARY_LIBRARY} PRIVATE ${DATA_DESCRIPTORS_INTERFACE_TARGET})
+
+ set(CONTRACT_BASELINE_DIR "${CLR_REPO_ROOT_DIR}/docs/design/datacontracts/data")
+ set(CONTRACT_DESCRIPTOR_INPUT "${DATA_DESCRIPTOR_SHARED_SOURCE_DIR}/contract-descriptor.c.in")
+ set(CONTRACT_DESCRIPTOR_OUTPUT "${GENERATED_CDAC_DESCRIPTOR_DIR}/contract-descriptor.c")
+ set(CONTRACT_FILE "${DATA_DESCRIPTORS_CONTRACT_FILE}")
+
+ # generate the contract descriptor by running cdac-build-tool
+ # n.b. this just uses `dotnet` from the PATH. InitializeDotNetCli adds the appropriate directory
+ add_custom_command(
+ OUTPUT "${CONTRACT_DESCRIPTOR_OUTPUT}"
+ VERBATIM
+ COMMAND ${CLR_DOTNET_HOST_PATH} ${CDAC_BUILD_TOOL_BINARY_PATH} compose -i "${CONTRACT_DESCRIPTOR_INPUT}" -o "${CONTRACT_DESCRIPTOR_OUTPUT}" -b "${CONTRACT_BASELINE_DIR}" -c "${CONTRACT_FILE}" $
+ DEPENDS ${INTERMEDIARY_LIBRARY} ${DATA_DESCRIPTORS_DEPENDENCIES} $ "${CONTRACT_FILE}" "${CONTRACT_DESCRIPTOR_INPUT}"
+ USES_TERMINAL
+ )
+
+ # It is important that LIBRARY is an object library;
+ # if it was static, linking it into the final dll would not export
+ # ${CONTRACT_NAME} since it is not referenced anywhere.
+ add_library_clr(${LIBRARY} OBJECT
+ "${CONTRACT_DESCRIPTOR_OUTPUT}"
+ "${DATA_DESCRIPTOR_SHARED_SOURCE_DIR}/contractpointerdata.cpp"
+ )
+ add_dependencies(${LIBRARY} ${INTERMEDIARY_LIBRARY})
+
+ target_include_directories(${LIBRARY} PRIVATE ${GENERATED_CDAC_DESCRIPTOR_DIR})
+
+ # inherit definitions, include directories, and dependencies from the INTERFACE target
+ target_link_libraries(${LIBRARY} PRIVATE ${DATA_DESCRIPTORS_INTERFACE_TARGET})
+
+ if(MSVC)
+ # /Zc:externConstexpr is required to export constexpr variables
+ # from the object file, otherwise the linker will not export them.
+ # See https://learn.microsoft.com/en-us/cpp/build/reference/zc-externconstexpr
+ # for more details.
+ target_compile_options(${LIBRARY} PRIVATE /Zc:externConstexpr)
+ endif(MSVC)
+ endif()
+endfunction(generate_data_descriptors)
diff --git a/src/coreclr/clrdefinitions.cmake b/src/coreclr/clrdefinitions.cmake
index 5e427d41f63210..ece4f875dcb0ee 100644
--- a/src/coreclr/clrdefinitions.cmake
+++ b/src/coreclr/clrdefinitions.cmake
@@ -152,8 +152,6 @@ if(FEATURE_OBJCMARSHAL)
add_compile_definitions(FEATURE_OBJCMARSHAL)
endif()
-# add_compile_definitions(FEATURE_RUNTIME_ASYNC)
-
add_compile_definitions($<${FEATURE_JAVAMARSHAL}:FEATURE_JAVAMARSHAL>)
add_compile_definitions($<$>>:FEATURE_PROFAPI_ATTACH_DETACH>)
@@ -209,6 +207,10 @@ if (FEATURE_STUBPRECODE_DYNAMIC_HELPERS)
add_definitions(-DFEATURE_STUBPRECODE_DYNAMIC_HELPERS)
endif()
+if (FEATURE_CORECLR_FLUSH_INSTRUCTION_CACHE_TO_PROTECT_STUB_READS)
+ add_definitions(-DFEATURE_CORECLR_FLUSH_INSTRUCTION_CACHE_TO_PROTECT_STUB_READS)
+endif()
+
if (CLR_CMAKE_TARGET_APPLE)
# Re-enable when dbgshim containing https://github.com/dotnet/diagnostics/pull/5487 is generally available
# add_definitions(-DFEATURE_MAP_THUNKS_FROM_IMAGE)
diff --git a/src/coreclr/clrfeatures.cmake b/src/coreclr/clrfeatures.cmake
index 01387330ed0694..9eb037300cd4f1 100644
--- a/src/coreclr/clrfeatures.cmake
+++ b/src/coreclr/clrfeatures.cmake
@@ -2,6 +2,10 @@ if (NOT CLR_CMAKE_TARGET_ARCH_WASM)
set(FEATURE_JIT 1)
endif()
+if (CLR_CMAKE_TARGET_ARCH_WASM OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+ set(FEATURE_STATICALLY_LINKED 1)
+endif()
+
if(CLR_CMAKE_TARGET_TIZEN_LINUX)
set(FEATURE_GDBJIT_LANGID_CS 1)
endif()
@@ -32,13 +36,15 @@ endif(NOT DEFINED FEATURE_DBGIPC)
if(NOT DEFINED FEATURE_INTERPRETER)
if(CLR_CMAKE_TARGET_ANDROID)
- set(FEATURE_INTERPRETER 0)
+ set(FEATURE_INTERPRETER 0)
+ elseif(CLR_CMAKE_TARGET_ARCH_WASM)
+ set(FEATURE_INTERPRETER 1)
else()
- if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
- set(FEATURE_INTERPRETER $,1,0>)
- else(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
- set(FEATURE_INTERPRETER 0)
- endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+ if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+ set(FEATURE_INTERPRETER $,1,0>)
+ else(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+ set(FEATURE_INTERPRETER 0)
+ endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
endif()
endif(NOT DEFINED FEATURE_INTERPRETER)
@@ -54,7 +60,7 @@ if(NOT DEFINED FEATURE_SINGLE_FILE_DIAGNOSTICS)
set(FEATURE_SINGLE_FILE_DIAGNOSTICS 1)
endif(NOT DEFINED FEATURE_SINGLE_FILE_DIAGNOSTICS)
-if (CLR_CMAKE_TARGET_WIN32 OR CLR_CMAKE_TARGET_UNIX)
+if ((CLR_CMAKE_TARGET_WIN32 OR CLR_CMAKE_TARGET_UNIX) AND NOT CLR_CMAKE_TARGET_ARCH_WASM)
set(FEATURE_COMWRAPPERS 1)
endif()
@@ -74,6 +80,9 @@ if (CLR_CMAKE_TARGET_WIN32)
set(FEATURE_TYPEEQUIVALENCE 1)
endif(CLR_CMAKE_TARGET_WIN32)
+if (CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS)
+ set(FEATURE_STUBPRECODE_DYNAMIC_HELPERS 1)
+endif()
if (CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS OR CLR_CMAKE_TARGET_ARCH_WASM)
set(FEATURE_CORECLR_CACHED_INTERFACE_DISPATCH 1)
@@ -89,6 +98,12 @@ else()
set(FEATURE_CORECLR_VIRTUAL_STUB_DISPATCH 1)
endif()
+# We use a flush instruction cache to protect reads from the StubPrecodeData/CallCountingStub structures in the stubs.
+# This is needed because the StubPrecodeData structure is initialized after the stub code is written, and we need to ensure that
+# the reads in the stub happen after the writes to the StubPrecodeData structure. We could do this with a barrier instruction in the stub,
+# but that would be more expensive.
+set(FEATURE_CORECLR_FLUSH_INSTRUCTION_CACHE_TO_PROTECT_STUB_READS 1)
+
if (CLR_CMAKE_HOST_UNIX AND CLR_CMAKE_HOST_ARCH_AMD64)
# Allow 16 byte compare-exchange (cmpxchg16b)
add_compile_options($<${FEATURE_CORECLR_CACHED_INTERFACE_DISPATCH}:-mcx16>)
diff --git a/src/coreclr/debug/daccess/cdac.cpp b/src/coreclr/debug/daccess/cdac.cpp
index 780b0d2abe29bb..738db6aeb6b2ed 100644
--- a/src/coreclr/debug/daccess/cdac.cpp
+++ b/src/coreclr/debug/daccess/cdac.cpp
@@ -43,6 +43,16 @@ namespace
return S_OK;
}
+ int WriteToTargetCallback(uint64_t addr, const uint8_t* buff, uint32_t count, void* context)
+ {
+ ICorDebugMutableDataTarget* target = static_cast(context);
+ HRESULT hr = target->WriteVirtual((CORDB_ADDRESS)addr, buff, count);
+ if (FAILED(hr))
+ return hr;
+
+ return S_OK;
+ }
+
int ReadThreadContext(uint32_t threadId, uint32_t contextFlags, uint32_t contextBufferSize, uint8_t* contextBuffer, void* context)
{
ICorDebugDataTarget* target = reinterpret_cast(context);
@@ -54,7 +64,7 @@ namespace
}
}
-CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugDataTarget* target, IUnknown* legacyImpl)
+CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugMutableDataTarget* target, IUnknown* legacyImpl)
{
HMODULE cdacLib;
if (!TryLoadCDACLibrary(&cdacLib))
@@ -64,7 +74,7 @@ CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugDataTarget* target, IUnknown
_ASSERTE(init != nullptr);
intptr_t handle;
- if (init(descriptorAddr, &ReadFromTargetCallback, &ReadThreadContext, target, &handle) != 0)
+ if (init(descriptorAddr, &ReadFromTargetCallback, &WriteToTargetCallback, &ReadThreadContext, target, &handle) != 0)
{
::FreeLibrary(cdacLib);
return {};
diff --git a/src/coreclr/debug/daccess/cdac.h b/src/coreclr/debug/daccess/cdac.h
index f6d1cdcbe5035b..559f20226df339 100644
--- a/src/coreclr/debug/daccess/cdac.h
+++ b/src/coreclr/debug/daccess/cdac.h
@@ -7,7 +7,7 @@
class CDAC final
{
public: // static
- static CDAC Create(uint64_t descriptorAddr, ICorDebugDataTarget *pDataTarget, IUnknown* legacyImpl);
+ static CDAC Create(uint64_t descriptorAddr, ICorDebugMutableDataTarget *pDataTarget, IUnknown* legacyImpl);
public:
CDAC() = default;
diff --git a/src/coreclr/debug/daccess/daccess.cpp b/src/coreclr/debug/daccess/daccess.cpp
index 1cdb0ce5c1d735..1282ed4e1ea4a0 100644
--- a/src/coreclr/debug/daccess/daccess.cpp
+++ b/src/coreclr/debug/daccess/daccess.cpp
@@ -4175,7 +4175,7 @@ ClrDataAccess::StartEnumMethodInstancesByAddress(
goto Exit;
}
- if (IsPossibleCodeAddress(taddr) != S_OK)
+ if ( (status = IsPossibleCodeAddress(taddr)) != S_OK)
{
goto Exit;
}
@@ -5990,6 +5990,7 @@ ClrDataAccess::GetMethodVarInfo(MethodDesc* methodDesc,
BOOL success = DebugInfoManager::GetBoundariesAndVars(
request,
DebugInfoStoreNew, NULL, // allocator
+ BoundsType::Instrumented,
NULL, NULL,
&countNativeVarInfo, &nativeVars);
@@ -6052,6 +6053,7 @@ ClrDataAccess::GetMethodNativeMap(MethodDesc* methodDesc,
BOOL success = DebugInfoManager::GetBoundariesAndVars(
request,
DebugInfoStoreNew, NULL, // allocator
+ BoundsType::Instrumented,
&countMapCopy, &mapCopy,
NULL, NULL);
@@ -7031,7 +7033,7 @@ CLRDataCreateInstance(REFIID iid,
HRESULT qiRes = pClrDataAccess->QueryInterface(IID_IUnknown, (void**)&thisImpl);
_ASSERTE(SUCCEEDED(qiRes));
CDAC& cdac = pClrDataAccess->m_cdac;
- cdac = CDAC::Create(contractDescriptorAddr, pClrDataAccess->m_pTarget, thisImpl);
+ cdac = CDAC::Create(contractDescriptorAddr, pClrDataAccess->m_pMutableTarget, thisImpl);
if (cdac.IsValid())
{
// Get SOS interfaces from the cDAC if available.
diff --git a/src/coreclr/debug/daccess/dacdbiimpl.cpp b/src/coreclr/debug/daccess/dacdbiimpl.cpp
index 992bbf5046a11e..0fa75ad43cf054 100644
--- a/src/coreclr/debug/daccess/dacdbiimpl.cpp
+++ b/src/coreclr/debug/daccess/dacdbiimpl.cpp
@@ -868,6 +868,7 @@ void DacDbiInterfaceImpl::GetNativeVarData(MethodDesc * pMethodDesc,
BOOL success = DebugInfoManager::GetBoundariesAndVars(request,
InfoStoreNew, NULL, // allocator
+ BoundsType::Instrumented,
NULL, NULL,
&entryCount, &nativeVars);
@@ -879,76 +880,6 @@ void DacDbiInterfaceImpl::GetNativeVarData(MethodDesc * pMethodDesc,
} // GetNativeVarData
-//-----------------------------------------------------------------------------
-// Given a instrumented IL map from the profiler that maps:
-// Original offset IL_A -> Instrumentend offset IL_B
-// And a native mapping from the JIT that maps:
-// Instrumented offset IL_B -> native offset Native_C
-// This function merges the two maps and stores the result back into the nativeMap.
-// The nativeMap now maps:
-// Original offset IL_A -> native offset Native_C
-// pEntryCount is the number of valid entries in nativeMap, and it may be adjusted downwards
-// as part of the composition.
-//-----------------------------------------------------------------------------
-void DacDbiInterfaceImpl::ComposeMapping(const InstrumentedILOffsetMapping * pProfilerILMap, ICorDebugInfo::OffsetMapping nativeMap[], ULONG32* pEntryCount)
-{
- // Translate the IL offset if the profiler has provided us with a mapping.
- // The ICD public API should always expose the original IL offsets, but GetBoundaries()
- // directly accesses the debug info, which stores the instrumented IL offsets.
-
- ULONG32 entryCount = *pEntryCount;
- // The map pointer could be NULL or there could be no entries in the map, in either case no work to do
- if (pProfilerILMap && !pProfilerILMap->IsNull())
- {
- // If we did instrument, then we can't have any sequence points that
- // are "in-between" the old-->new map that the profiler gave us.
- // Ex, if map is:
- // (6 old -> 36 new)
- // (8 old -> 50 new)
- // And the jit gives us an entry for 44 new, that will map back to 6 old.
- // Since the map can only have one entry for 6 old, we remove 44 new.
-
- // First Pass: invalidate all the duplicate entries by setting their IL offset to MAX_ILNUM
- ULONG32 cDuplicate = 0;
- ULONG32 prevILOffset = (ULONG32)(ICorDebugInfo::MAX_ILNUM);
- for (ULONG32 i = 0; i < entryCount; i++)
- {
- ULONG32 origILOffset = TranslateInstrumentedILOffsetToOriginal(nativeMap[i].ilOffset, pProfilerILMap);
-
- if (origILOffset == prevILOffset)
- {
- // mark this sequence point as invalid; refer to the comment above
- nativeMap[i].ilOffset = (ULONG32)(ICorDebugInfo::MAX_ILNUM);
- cDuplicate += 1;
- }
- else
- {
- // overwrite the instrumented IL offset with the original IL offset
- nativeMap[i].ilOffset = origILOffset;
- prevILOffset = origILOffset;
- }
- }
-
- // Second Pass: move all the valid entries up front
- ULONG32 realIndex = 0;
- for (ULONG32 curIndex = 0; curIndex < entryCount; curIndex++)
- {
- if (nativeMap[curIndex].ilOffset != (ULONG32)(ICorDebugInfo::MAX_ILNUM))
- {
- // This is a valid entry. Move it up front.
- nativeMap[realIndex] = nativeMap[curIndex];
- realIndex += 1;
- }
- }
-
- // make sure we have done the bookkeeping correctly
- _ASSERTE((realIndex + cDuplicate) == entryCount);
-
- // Final Pass: derecement entryCount
- entryCount -= cDuplicate;
- *pEntryCount = entryCount;
- }
-}
//-----------------------------------------------------------------------------
@@ -983,38 +914,14 @@ void DacDbiInterfaceImpl::GetSequencePoints(MethodDesc * pMethodDesc,
ULONG32 entryCount;
BOOL success = DebugInfoManager::GetBoundariesAndVars(request,
- InfoStoreNew, NULL, // allocator
+ InfoStoreNew,
+ NULL, // allocator
+ BoundsType::Uninstrumented,
&entryCount, &mapCopy,
NULL, NULL);
if (!success)
ThrowHR(E_FAIL);
-#ifdef FEATURE_REJIT
- CodeVersionManager * pCodeVersionManager = pMethodDesc->GetCodeVersionManager();
- ILCodeVersion ilVersion;
- NativeCodeVersion nativeCodeVersion = pCodeVersionManager->GetNativeCodeVersion(dac_cast(pMethodDesc), (PCODE)startAddr);
- if (!nativeCodeVersion.IsNull())
- {
- ilVersion = nativeCodeVersion.GetILCodeVersion();
- }
-
- // if there is a rejit IL map for this function, apply that in preference to load-time mapping
- if (!ilVersion.IsNull() && !ilVersion.IsDefaultVersion())
- {
- const InstrumentedILOffsetMapping * pRejitMapping = ilVersion.GetInstrumentedILMap();
- ComposeMapping(pRejitMapping, mapCopy, &entryCount);
- }
- else
- {
-#endif
- // if there is a profiler load-time mapping and not a rejit mapping, apply that instead
- InstrumentedILOffsetMapping loadTimeMapping =
- pMethodDesc->GetAssembly()->GetModule()->GetInstrumentedILOffsetMapping(pMethodDesc->GetMemberDef());
- ComposeMapping(&loadTimeMapping, mapCopy, &entryCount);
-#ifdef FEATURE_REJIT
- }
-#endif
-
pSeqPoints->InitSequencePoints(entryCount);
// mapCopy and pSeqPoints have elements of different types. Thus, we
@@ -1024,46 +931,6 @@ void DacDbiInterfaceImpl::GetSequencePoints(MethodDesc * pMethodDesc,
} // GetSequencePoints
-// ----------------------------------------------------------------------------
-// DacDbiInterfaceImpl::TranslateInstrumentedILOffsetToOriginal
-//
-// Description:
-// Helper function to convert an instrumented IL offset to the corresponding original IL offset.
-//
-// Arguments:
-// * ilOffset - offset to be translated
-// * pMapping - the profiler-provided mapping between original IL offsets and instrumented IL offsets
-//
-// Return Value:
-// Return the translated offset.
-//
-
-ULONG DacDbiInterfaceImpl::TranslateInstrumentedILOffsetToOriginal(ULONG ilOffset,
- const InstrumentedILOffsetMapping * pMapping)
-{
- SIZE_T cMap = pMapping->GetCount();
- ARRAY_PTR_COR_IL_MAP rgMap = pMapping->GetOffsets();
-
- _ASSERTE((cMap == 0) == (rgMap == NULL));
-
- // Early out if there is no mapping, or if we are dealing with a special IL offset such as
- // prolog, epilog, etc.
- if ((cMap == 0) || ((int)ilOffset < 0))
- {
- return ilOffset;
- }
-
- SIZE_T i = 0;
- for (i = 1; i < cMap; i++)
- {
- if (ilOffset < rgMap[i].newOffset)
- {
- return rgMap[i - 1].oldOffset;
- }
- }
- return rgMap[i - 1].oldOffset;
-}
-
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Function Data
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -3556,9 +3423,9 @@ void DacDbiInterfaceImpl::EnumerateMemRangesForJitCodeHeaps(CQuickArrayListm_pCodeHeap.IsValid());
+ _ASSERTE(pEM != NULL && pEM->m_pAllCodeHeaps.IsValid());
- PTR_HeapList pHeapList = pEM->m_pCodeHeap;
+ PTR_HeapList pHeapList = pEM->m_pAllCodeHeaps;
while (pHeapList != NULL)
{
CodeHeap *pHeap = pHeapList->pHeap;
@@ -5096,9 +4963,21 @@ void DacDbiInterfaceImpl::Hijack(
// Setup context for hijack
//
T_CONTEXT ctx;
+#if !defined(CROSS_COMPILE) && !defined(TARGET_WINDOWS) && (defined(DTCONTEXT_IS_AMD64) || defined(DTCONTEXT_IS_ARM64))
+ // If the host or target is not Windows, then we can assume that the DT_CONTEXT
+ // is the same as the T_CONTEXT, except for the XSTATE registers.
+ static_assert(sizeof(DT_CONTEXT) == offsetof(T_CONTEXT, XStateFeaturesMask), "DT_CONTEXT does not include the XSTATE registers");
+#else
+ // Since Dac + DBI are tightly coupled, context sizes should be the same.
+ static_assert(sizeof(DT_CONTEXT) == sizeof(T_CONTEXT), "DT_CONTEXT size must equal the T_CONTEXT size");
+#endif
HRESULT hr = m_pTarget->GetThreadContext(
dwThreadId,
- CONTEXT_FULL,
+ CONTEXT_FULL | CONTEXT_FLOATING_POINT
+#ifdef CONTEXT_EXTENDED_REGISTERS
+ | CONTEXT_EXTENDED_REGISTERS
+#endif
+ ,
sizeof(DT_CONTEXT),
(BYTE*) &ctx);
IfFailThrow(hr);
@@ -7445,6 +7324,23 @@ HRESULT DacDbiInterfaceImpl::EnableGCNotificationEvents(BOOL fEnable)
return hr;
}
+HRESULT DacDbiInterfaceImpl::GetDomainAssemblyFromModule(VMPTR_Module vmModule, OUT VMPTR_DomainAssembly *pVmDomainAssembly)
+{
+ DD_ENTER_MAY_THROW;
+
+ if (vmModule.IsNull() || pVmDomainAssembly == NULL)
+ return E_INVALIDARG;
+
+ Module *pModule = vmModule.GetDacPtr();
+ if (pModule == NULL)
+ return E_INVALIDARG;
+
+ *pVmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
+ pVmDomainAssembly->SetHostPtr(pModule->GetDomainAssembly());
+
+ return S_OK;
+}
+
DacRefWalker::DacRefWalker(ClrDataAccess *dac, BOOL walkStacks, BOOL walkFQ, UINT32 handleMask, BOOL resolvePointers)
: mDac(dac), mWalkStacks(walkStacks), mWalkFQ(walkFQ), mHandleMask(handleMask), mStackWalker(NULL),
mResolvePointers(resolvePointers), mHandleWalker(NULL), mFQStart(PTR_NULL), mFQEnd(PTR_NULL), mFQCurr(PTR_NULL)
diff --git a/src/coreclr/debug/daccess/dacdbiimpl.h b/src/coreclr/debug/daccess/dacdbiimpl.h
index dffc8115e603b0..c1ae09a3feaf0a 100644
--- a/src/coreclr/debug/daccess/dacdbiimpl.h
+++ b/src/coreclr/debug/daccess/dacdbiimpl.h
@@ -162,6 +162,7 @@ class DacDbiInterfaceImpl :
HRESULT GetDefinesBitField(ULONG32 *pDefines);
HRESULT GetMDStructuresVersion(ULONG32* pMDStructuresVersion);
HRESULT EnableGCNotificationEvents(BOOL fEnable);
+ HRESULT GetDomainAssemblyFromModule(VMPTR_Module vmModule, OUT VMPTR_DomainAssembly *pVmDomainAssembly);
private:
void TypeHandleToExpandedTypeInfoImpl(AreValueTypesBoxed boxed,
@@ -183,13 +184,6 @@ class DacDbiInterfaceImpl :
CORDB_ADDRESS startAddr,
SequencePoints * pNativeMap);
- // Helper to compose a IL->IL and IL->Native mapping
- void ComposeMapping(const InstrumentedILOffsetMapping * pProfilerILMap, ICorDebugInfo::OffsetMapping nativeMap[], ULONG32* pEntryCount);
-
- // Helper function to convert an instrumented IL offset to the corresponding original IL offset.
- ULONG TranslateInstrumentedILOffsetToOriginal(ULONG ilOffset,
- const InstrumentedILOffsetMapping * pMapping);
-
public:
//----------------------------------------------------------------------------------
// class MapSortILMap: A template class that will sort an array of DebuggerILToNativeMap.
diff --git a/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp b/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp
index eb5464275d0dc2..dc13cf59a7f006 100644
--- a/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp
+++ b/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp
@@ -474,7 +474,7 @@ ULONG32 DacDbiInterfaceImpl::GetCountOfInternalFrames(VMPTR_Thread vmThread)
{
// Skip new exception handling helpers
InlinedCallFrame *pInlinedCallFrame = dac_cast(pFrame);
- PTR_NDirectMethodDesc pMD = pInlinedCallFrame->m_Datum;
+ PTR_PInvokeMethodDesc pMD = pInlinedCallFrame->m_Datum;
TADDR datum = dac_cast(pMD);
if ((datum & (TADDR)InlinedCallFrameMarker::Mask) == (TADDR)InlinedCallFrameMarker::ExceptionHandlingHelper)
{
@@ -527,7 +527,7 @@ void DacDbiInterfaceImpl::EnumerateInternalFrames(VMPTR_Thread
{
// Skip new exception handling helpers
InlinedCallFrame *pInlinedCallFrame = dac_cast(pFrame);
- PTR_NDirectMethodDesc pMD = pInlinedCallFrame->m_Datum;
+ PTR_PInvokeMethodDesc pMD = pInlinedCallFrame->m_Datum;
TADDR datum = dac_cast(pMD);
if ((datum & (TADDR)InlinedCallFrameMarker::Mask) == (TADDR)InlinedCallFrameMarker::ExceptionHandlingHelper)
{
diff --git a/src/coreclr/debug/daccess/enummem.cpp b/src/coreclr/debug/daccess/enummem.cpp
index 4c360628edfac5..828ae77d6aae16 100644
--- a/src/coreclr/debug/daccess/enummem.cpp
+++ b/src/coreclr/debug/daccess/enummem.cpp
@@ -25,6 +25,8 @@
#include
#endif // FEATURE_COMWRAPPERS
+#include "cdacplatformmetadata.hpp"
+
extern HRESULT GetDacTableAddress(ICorDebugDataTarget* dataTarget, ULONG64 baseAddress, PULONG64 dacTableAddress);
#if defined(DAC_MEASURE_PERF)
diff --git a/src/coreclr/debug/daccess/fntableaccess.cpp b/src/coreclr/debug/daccess/fntableaccess.cpp
index 023a82e268c8ed..5583da327a6727 100644
--- a/src/coreclr/debug/daccess/fntableaccess.cpp
+++ b/src/coreclr/debug/daccess/fntableaccess.cpp
@@ -169,7 +169,7 @@ extern "C" NTSTATUS OutOfProcessFunctionTableCallbackEx(IN ReadMemoryFunction
*ppFunctions = 0;
*pnEntries = 0;
- DWORD_PTR pHp = JitMan + (DWORD_PTR)offsetof(FakeEEJitManager, m_pCodeHeap);
+ DWORD_PTR pHp = JitMan + (DWORD_PTR)offsetof(FakeEEJitManager, m_pAllCodeHeaps);
move(pHp, pHp);
diff --git a/src/coreclr/debug/daccess/fntableaccess.h b/src/coreclr/debug/daccess/fntableaccess.h
index f76056cfba0379..db4bdfe1e3414c 100644
--- a/src/coreclr/debug/daccess/fntableaccess.h
+++ b/src/coreclr/debug/daccess/fntableaccess.h
@@ -15,8 +15,8 @@ struct FakeEEJitManager
{
LPVOID __VFN_table;
LPVOID m_runtimeSupport;
- LPVOID m_pCodeHeap;
- // Nothing after this point matters: we only need the correct offset of m_pCodeHeap.
+ LPVOID m_pAllCodeHeaps;
+ // Nothing after this point matters: we only need the correct offset of m_pAllCodeHeaps.
};
struct FakeHeapList
@@ -76,7 +76,7 @@ class CheckDuplicatedStructLayouts
{
#define CHECK_OFFSET(cls, fld) CPP_ASSERT(cls##fld, offsetof(Fake##cls, fld) == offsetof(cls, fld))
- CHECK_OFFSET(EEJitManager, m_pCodeHeap);
+ CHECK_OFFSET(EEJitManager, m_pAllCodeHeaps);
CHECK_OFFSET(HeapList, hpNext);
CHECK_OFFSET(HeapList, startAddress);
diff --git a/src/coreclr/debug/daccess/reimpl.cpp b/src/coreclr/debug/daccess/reimpl.cpp
index 1935eacce97258..fe6f1adddc786e 100644
--- a/src/coreclr/debug/daccess/reimpl.cpp
+++ b/src/coreclr/debug/daccess/reimpl.cpp
@@ -38,9 +38,9 @@ DacGetThread(ULONG32 osThread)
UNREACHABLE();
}
- // Note that if we had access to TLS, we could get this at index gThreadTLSIndex for the specified
- // thread. However, this is the only place we might want to use TLS, and it's not performance critical,
- // so we haven't added TLS support to ICorDebugDataTarget (the legacy ICLRDataTarget interface has it though)
+ // Note that if we had access to TLS, we could get this at TLS for the specified thread. However, this is
+ // the only place we might want to use TLS, and it's not performance critical, so we haven't added TLS support
+ // to ICorDebugDataTarget (the legacy ICLRDataTarget interface has it though)
// Scan the whole thread store to see if there's a matching thread.
diff --git a/src/coreclr/debug/daccess/request.cpp b/src/coreclr/debug/daccess/request.cpp
index ccb303453b5626..9f567d48809b39 100644
--- a/src/coreclr/debug/daccess/request.cpp
+++ b/src/coreclr/debug/daccess/request.cpp
@@ -362,7 +362,7 @@ ClrDataAccess::GetJitManagerList(unsigned int count, struct DacpJitManagerInfo m
currentPtr->codeType = managerPtr->GetCodeType();
EEJitManager *eeJitManager = PTR_EEJitManager(PTR_HOST_TO_TADDR(managerPtr));
- currentPtr->ptrHeapList = HOST_CDADDR(eeJitManager->m_pCodeHeap);
+ currentPtr->ptrHeapList = HOST_CDADDR(eeJitManager->m_pAllCodeHeaps);
}
}
else if (pNeeded)
@@ -528,7 +528,7 @@ ClrDataAccess::GetCodeHeapList(CLRDATA_ADDRESS jitManager, unsigned int count, s
SOSDacEnter();
EEJitManager *pJitManager = PTR_EEJitManager(TO_TADDR(jitManager));
- HeapList *heapList = pJitManager->m_pCodeHeap;
+ HeapList *heapList = pJitManager->m_pAllCodeHeaps;
if (codeHeaps)
{
@@ -2434,32 +2434,26 @@ ClrDataAccess::GetAppDomainData(CLRDATA_ADDRESS addr, struct DacpAppDomainData *
if (addr != HOST_CDADDR(SystemDomain::System()))
{
PTR_AppDomain pAppDomain = PTR_AppDomain(TO_TADDR(addr));
- appdomainData->DomainLocalBlock = 0;
- appdomainData->pDomainLocalModules = 0;
appdomainData->dwId = DefaultADID;
- appdomainData->appDomainStage = (DacpAppDomainDataStage)pAppDomain->m_Stage.Load();
- if (pAppDomain->IsActive())
- {
- // The assembly list is not valid in a closed appdomain.
- AppDomain::AssemblyIterator i = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)(
- kIncludeLoading | kIncludeLoaded | kIncludeExecution));
- CollectibleAssemblyHolder pAssembly;
- while (i.Next(pAssembly.This()))
- {
- if (pAssembly->IsLoaded())
- {
- appdomainData->AssemblyCount++;
- }
- }
+ AppDomain::AssemblyIterator i = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)(
+ kIncludeLoading | kIncludeLoaded | kIncludeExecution));
+ CollectibleAssemblyHolder pAssembly;
- AppDomain::FailedAssemblyIterator j = pAppDomain->IterateFailedAssembliesEx();
- while (j.Next())
+ while (i.Next(pAssembly.This()))
+ {
+ if (pAssembly->IsLoaded())
{
- appdomainData->FailedAssemblyCount++;
+ appdomainData->AssemblyCount++;
}
}
+
+ AppDomain::FailedAssemblyIterator j = pAppDomain->IterateFailedAssembliesEx();
+ while (j.Next())
+ {
+ appdomainData->FailedAssemblyCount++;
+ }
}
}
@@ -5030,15 +5024,15 @@ HRESULT ClrDataAccess::GetAssemblyLoadContext(CLRDATA_ADDRESS methodTable, CLRDA
PTR_PEAssembly pPEAssembly = pModule->GetPEAssembly();
PTR_AssemblyBinder pBinder = pPEAssembly->GetAssemblyBinder();
- INT_PTR managedAssemblyLoadContextHandle = pBinder->GetManagedAssemblyLoadContext();
+ INT_PTR AssemblyLoadContextHandle = pBinder->GetAssemblyLoadContext();
- TADDR managedAssemblyLoadContextAddr = 0;
- if (managedAssemblyLoadContextHandle != 0)
+ TADDR AssemblyLoadContextAddr = 0;
+ if (AssemblyLoadContextHandle != 0)
{
- DacReadAll(managedAssemblyLoadContextHandle,&managedAssemblyLoadContextAddr,sizeof(TADDR),true);
+ DacReadAll(AssemblyLoadContextHandle,&AssemblyLoadContextAddr,sizeof(TADDR),true);
}
- *assemblyLoadContext = TO_CDADDR(managedAssemblyLoadContextAddr);
+ *assemblyLoadContext = TO_CDADDR(AssemblyLoadContextAddr);
SOSDacLeave();
return hr;
diff --git a/src/coreclr/debug/daccess/stdafx.h b/src/coreclr/debug/daccess/stdafx.h
index bb7b7b2365de59..bff6a4f660379b 100644
--- a/src/coreclr/debug/daccess/stdafx.h
+++ b/src/coreclr/debug/daccess/stdafx.h
@@ -42,6 +42,7 @@
#include
#include
#include
+#include
#include
#include
#include
diff --git a/src/coreclr/debug/daccess/task.cpp b/src/coreclr/debug/daccess/task.cpp
index b55626e2d33185..edbb360a988c36 100644
--- a/src/coreclr/debug/daccess/task.cpp
+++ b/src/coreclr/debug/daccess/task.cpp
@@ -3573,13 +3573,13 @@ ClrDataMethodDefinition::GetIlMethod(void)
{
if (m_methodDesc)
{
- if (!m_methodDesc->HasILHeader())
+ if (m_methodDesc->MayHaveILHeader())
{
- return NULL;
+ return m_methodDesc->GetILHeader();
}
else
{
- return m_methodDesc->GetILHeader();
+ return NULL;
}
}
else
diff --git a/src/coreclr/debug/datadescriptor-shared/README.md b/src/coreclr/debug/datadescriptor-shared/README.md
new file mode 100644
index 00000000000000..b0bb9e8e3dc1d3
--- /dev/null
+++ b/src/coreclr/debug/datadescriptor-shared/README.md
@@ -0,0 +1,99 @@
+# Datadescriptor Implementation Infrastructure
+
+This folder contains infrastructure to create data descriptors as defined in the [data_descriptor.md](../../../../docs/design/datacontracts/data_descriptor.md). Data descriptors enable diagnostic tooling (debuggers, profilers, etc.) to understand the internal layout and structure of .NET runtime objects without requiring intimate knowledge of implementation details.
+
+## CMake Integration and Build System
+
+### Function Parameters
+
+The `generate_data_descriptors` function defined in `clrdatadescriptors.cmake` takes the following arguments:
+
+* **`LIBRARY_NAME`** (Required) - Sets the name of the target object being created
+* **`CONTRACT_FILE`** (Required) - Path to the contract JSON file defining supported contracts
+* **`CONTRACT_NAME`** (Required) - Name of the `ContractDescriptor` export symbol
+* **`INTERFACE_TARGET`** (Required) - Interface target providing dependencies, include directories, and definitions
+* **`EXPORT_VISIBLE`** (Optional) - Controls if the `CONTRACT_NAME` will be exported from the DLL
+
+### Two-Phase Build Process
+
+The build system uses a two-phase approach:
+
+**Phase 1: Intermediary Library**
+- Compiles `datadescriptor.cpp` with your `datadescriptor.h` and `datadescriptor.inc`
+- Creates object files that the `cdac-build-tool` can analyze
+- Extracts type layout information and generates string pools
+
+**Phase 2: Contract Descriptor Generation**
+- Runs `cdac-build-tool` to process the intermediary object files
+- Generates the final contract descriptor C source file
+- Compiles this into the final library that gets linked into the runtime
+
+
+## Macro Reference
+
+### Structure Definition Macros
+
+**`CDAC_BASELINE("identifier")`**
+- Specifies the baseline data contract version
+- Use `"empty"` for new descriptors
+- Must appear before any other content
+
+**`CDAC_TYPES_BEGIN()` / `CDAC_TYPES_END()`**
+- Delimits the type definitions section
+- Must contain all `CDAC_TYPE_*` macros
+
+**`CDAC_TYPE_BEGIN(typeName)`**
+- Starts a new type definition
+- `typeName` must be globally unique within the descriptor
+
+**`CDAC_TYPE_SIZE(sizeInBytes)`**
+- Specifies the type has a determinate size
+- Usually `sizeof(YourNativeType)`
+
+**`CDAC_TYPE_INDETERMINATE(typeName)`**
+- Specifies the type has indeterminate size
+- Alternative to `CDAC_TYPE_SIZE`
+
+**`CDAC_TYPE_FIELD(typeName, fieldType, fieldName, offset)`**
+- Defines a field within the type
+- `fieldType`: primitive type or another defined type
+- `fieldName`: diagnostic-friendly name (use managed names for managed types)
+- `offset`: byte offset, usually `offsetof()` or `cdac_data::FieldName`
+
+**`CDAC_TYPE_END(typeName)`**
+- Closes the type definition
+- `typeName` must match the corresponding `CDAC_TYPE_BEGIN`
+
+### Global Value Macros
+
+**`CDAC_GLOBALS_BEGIN()` / `CDAC_GLOBALS_END()`**
+- Delimits the global values section
+
+**`CDAC_GLOBAL(globalName, typeName, value)`**
+- Defines a global literal value
+- `value` must be a compile-time constant
+- `typeName` can be a primitive type or defined type
+
+**`CDAC_GLOBAL_POINTER(globalName, address)`**
+- Defines a global pointer value
+- `address` must be a compile-time constant pointer or `uintptr_t`
+
+**`CDAC_GLOBAL_STRING(globalName, stringValue)`**
+- Defines a global string value
+- `stringValue` must be a compile-time string literal
+
+
+## Current Implementation
+
+For reference, see the current implementation in:
+- **`src/coreclr/vm/datadescriptor/`** - Complete real-world implementation
+ - `datadescriptor.h` - Headers and includes
+ - `datadescriptor.inc` - Full type definitions for runtime objects
+ - `contracts.jsonc` - Contract definitions
+ - `CMakeLists.txt` - Build integration
+
+## Related Documentation
+
+- **[Data Contracts Design](../../../../docs/design/datacontracts/datacontracts_design.md)** - Overall design and motivation
+- **[Contract Descriptor](../../../../docs/design/datacontracts/contract-descriptor.md)** - Binary format specification
+- **[Data Descriptor](../../../../docs/design/datacontracts/data_descriptor.md)** - Logical format specification
diff --git a/src/coreclr/debug/runtimeinfo/contract-descriptor.c.in b/src/coreclr/debug/datadescriptor-shared/contract-descriptor.c.in
similarity index 63%
rename from src/coreclr/debug/runtimeinfo/contract-descriptor.c.in
rename to src/coreclr/debug/datadescriptor-shared/contract-descriptor.c.in
index c1f0edd7a66f9c..8da6f70498461f 100644
--- a/src/coreclr/debug/runtimeinfo/contract-descriptor.c.in
+++ b/src/coreclr/debug/datadescriptor-shared/contract-descriptor.c.in
@@ -2,6 +2,7 @@
// The .NET Foundation licenses this file to you under the MIT license.
#include
+#include "contractconfiguration.h"
#ifdef _MSC_VER
#define DLLEXPORT __declspec(dllexport)
@@ -9,7 +10,7 @@
#define DLLEXPORT __attribute__((visibility("default")))
#endif
-struct DotNetRuntimeContractDescriptor
+struct ContractDescriptor
{
uint64_t magic;
uint32_t flags;
@@ -17,18 +18,21 @@ struct DotNetRuntimeContractDescriptor
const char *descriptor;
const uint32_t pointer_data_count;
uint32_t pad0;
- const uintptr_t *pointer_data;
+ const void** pointer_data;
};
-extern const uintptr_t contractDescriptorPointerData[];
+// POINTER_DATA_NAME and CONTRACT_NAME are macros provided by
+// contractconfiguration.h which is configured by CMake
+extern const void* POINTER_DATA_NAME[];
-DLLEXPORT struct DotNetRuntimeContractDescriptor DotNetRuntimeContractDescriptor;
-
-DLLEXPORT struct DotNetRuntimeContractDescriptor DotNetRuntimeContractDescriptor = {
+#if EXPORT_CONTRACT
+DLLEXPORT
+#endif // EXPORT_CONTRACT
+struct ContractDescriptor CONTRACT_NAME = {
.magic = 0x0043414443434e44ull, // "DNCCDAC\0"
.flags = %%platformFlags%%,
.descriptor_size = %%jsonDescriptorSize%%,
.descriptor = "%%jsonDescriptor%%",
.pointer_data_count = %%pointerDataCount%%,
- .pointer_data = &contractDescriptorPointerData[0],
+ .pointer_data = &POINTER_DATA_NAME[0],
};
diff --git a/src/coreclr/debug/datadescriptor-shared/contractconfiguration.h.in b/src/coreclr/debug/datadescriptor-shared/contractconfiguration.h.in
new file mode 100644
index 00000000000000..e38f320a8de5ac
--- /dev/null
+++ b/src/coreclr/debug/datadescriptor-shared/contractconfiguration.h.in
@@ -0,0 +1,6 @@
+#pragma once
+
+#define POINTER_DATA_NAME @POINTER_DATA_NAME@
+#define CONTRACT_NAME @CONTRACT_NAME@
+
+#define EXPORT_CONTRACT @EXPORT_CONTRACT@
diff --git a/src/coreclr/debug/runtimeinfo/contractdescriptorstub.c b/src/coreclr/debug/datadescriptor-shared/contractdescriptorstub.c
similarity index 64%
rename from src/coreclr/debug/runtimeinfo/contractdescriptorstub.c
rename to src/coreclr/debug/datadescriptor-shared/contractdescriptorstub.c
index 59421a6692d2a7..e403b4711eb61d 100644
--- a/src/coreclr/debug/runtimeinfo/contractdescriptorstub.c
+++ b/src/coreclr/debug/datadescriptor-shared/contractdescriptorstub.c
@@ -2,6 +2,7 @@
// The .NET Foundation licenses this file to you under the MIT license.
#include
+#include "contractconfiguration.h"
#ifdef _MSC_VER
#define DLLEXPORT __declspec(dllexport)
@@ -9,7 +10,7 @@
#define DLLEXPORT __attribute__((visibility("default")))
#endif
-struct DotNetRuntimeContractDescriptor
+struct ContractDescriptor
{
uint64_t magic;
uint32_t flags;
@@ -17,23 +18,25 @@ struct DotNetRuntimeContractDescriptor
const char *descriptor;
const uint32_t pointer_data_count;
uint32_t pad0;
- const uintptr_t *pointer_data;
+ const void** pointer_data;
};
-extern const uintptr_t contractDescriptorPointerData[];
+// POINTER_DATA_NAME and CONTRACT_NAME are macros provided by
+// contractconfiguration.h which is configured by CMake
+extern const void* POINTER_DATA_NAME[];
// just the placeholder pointer
-const uintptr_t contractDescriptorPointerData[] = { (uintptr_t)0 };
+const void* POINTER_DATA_NAME[] = { (void*)0 };
-DLLEXPORT struct DotNetRuntimeContractDescriptor DotNetRuntimeContractDescriptor;
+DLLEXPORT struct ContractDescriptor CONTRACT_NAME;
#define STUB_DESCRIPTOR "{\"version\":0,\"baseline\":\"empty\",\"contracts\":{},\"types\":{},\"globals\":{}}"
-DLLEXPORT struct DotNetRuntimeContractDescriptor DotNetRuntimeContractDescriptor = {
+DLLEXPORT struct ContractDescriptor CONTRACT_NAME = {
.magic = 0x0043414443434e44ull, // "DNCCDAC\0"
.flags = 0x1u & (sizeof(void*) == 4 ? 0x02u : 0x00u),
.descriptor_size = sizeof(STUB_DESCRIPTOR),
.descriptor = STUB_DESCRIPTOR,
.pointer_data_count = 1,
- .pointer_data = &contractDescriptorPointerData[0],
+ .pointer_data = &POINTER_DATA_NAME[0],
};
diff --git a/src/coreclr/debug/datadescriptor-shared/contractpointerdata.cpp b/src/coreclr/debug/datadescriptor-shared/contractpointerdata.cpp
new file mode 100644
index 00000000000000..443c7f182c001f
--- /dev/null
+++ b/src/coreclr/debug/datadescriptor-shared/contractpointerdata.cpp
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "datadescriptor.h"
+#include "contractconfiguration.h"
+
+extern "C"
+{
+ // without an extern declaration, clang does not emit this global into the object file
+ extern constexpr const void* POINTER_DATA_NAME[] = {
+ (void*)0, // placeholder
+ #define CDAC_GLOBAL_POINTER(name,value) (void*)(value),
+ #define CDAC_GLOBAL_SUB_DESCRIPTOR(name,value) (void*)(value),
+ #include "wrappeddatadescriptor.inc"
+ };
+};
+
diff --git a/src/coreclr/debug/runtimeinfo/datadescriptor.cpp b/src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp
similarity index 94%
rename from src/coreclr/debug/runtimeinfo/datadescriptor.cpp
rename to src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp
index 61e9732d5e133a..0e3332539df9ec 100644
--- a/src/coreclr/debug/runtimeinfo/datadescriptor.cpp
+++ b/src/coreclr/debug/datadescriptor-shared/datadescriptor.cpp
@@ -1,27 +1,7 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
-#include "common.h"
-
-#include
-#include
-
-#include "static_assert.h"
-
-#include
-#include "cdacplatformmetadata.hpp"
-#include "methodtable.h"
-#include "threads.h"
-#include "exinfo.h"
-
-#include "configure.h"
-
-#include "../debug/ee/debugger.h"
-#include "ecall.h"
-
-#ifdef HAVE_GCCOVER
-#include "gccover.h"
-#endif // HAVE_GCCOVER
+#include "datadescriptor.h"
// begin blob definition
@@ -90,7 +70,7 @@ struct CDacStringPoolSizes
#define CDAC_GLOBAL_POINTER(name,value) DECL_LEN(MAKE_GLOBALLEN_NAME(name), sizeof(#name))
#define CDAC_GLOBAL(name,tyname,value) DECL_LEN(MAKE_GLOBALLEN_NAME(name), sizeof(#name)) \
DECL_LEN(MAKE_GLOBALTYPELEN_NAME(name), sizeof(#tyname))
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
char cdac_string_pool_trailing_nil;
#undef DECL_LEN
};
@@ -108,7 +88,7 @@ enum
CDacBlobTypesCount =
#define CDAC_TYPES_BEGIN() 0
#define CDAC_TYPE_BEGIN(name) + 1
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
};
// count the field pool size.
@@ -119,7 +99,7 @@ enum
#define CDAC_TYPES_BEGIN() 1
#define CDAC_TYPE_FIELD(tyname,membertyname,membername,offset) + 1
#define CDAC_TYPE_END(name) + 1
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
};
// count the literal globals
@@ -128,7 +108,7 @@ enum
CDacBlobGlobalLiteralsCount =
#define CDAC_GLOBALS_BEGIN() 0
#define CDAC_GLOBAL(name,tyname,value) + 1
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
};
// count the aux vector globals
@@ -137,7 +117,7 @@ enum
CDacBlobGlobalPointersCount =
#define CDAC_GLOBALS_BEGIN() 0
#define CDAC_GLOBAL_POINTER(name,value) + 1
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
};
// count the global strings
@@ -146,7 +126,7 @@ enum
CDacBlobGlobalStringsCount =
#define CDAC_GLOBALS_BEGIN() 0
#define CDAC_GLOBAL_STRING(name,value) + 1
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
};
@@ -176,7 +156,7 @@ struct CDacFieldsPoolSizes
#define CDAC_TYPE_FIELD(tyname,membertyname,membername,offset) DECL_LEN(CONCAT4(cdac_fields_pool_member__, tyname, __, membername))
#define CDAC_TYPE_END(name) DECL_LEN(CONCAT4(cdac_fields_pool_member__, tyname, _, endmarker)) \
} MAKE_TYPEFIELDS_TYNAME(name);
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
#undef DECL_LEN
};
@@ -198,7 +178,7 @@ struct CDacGlobalPointerIndex
#define DECL_LEN(membername) char membername;
#define CDAC_GLOBALS_BEGIN() DECL_LEN(cdac_global_pointer_index_start_placeholder__)
#define CDAC_GLOBAL_POINTER(name,value) DECL_LEN(CONCAT(cdac_global_pointer_index__, name))
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
#undef DECL_LEN
};
@@ -296,7 +276,7 @@ struct MagicAndBlob BlobDataDescriptor = {
#define CDAC_TYPE_INDETERMINATE(name) /*.Size = */ 0,
#define CDAC_TYPE_SIZE(size) /* .Size = */ size,
#define CDAC_TYPE_END(name) },
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
},
/* .FieldsPool = */ {
@@ -307,22 +287,22 @@ struct MagicAndBlob BlobDataDescriptor = {
/* .FieldOffset = */ offset, \
},
#define CDAC_TYPE_END(name) { 0, },
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
},
/* .GlobalLiteralValues = */ {
#define CDAC_GLOBAL(name,tyname,value) { /*.Name = */ GET_GLOBAL_NAME(name), /* .TypeName = */ GET_GLOBALTYPE_NAME(name), /* .Value = */ value },
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
},
/* .GlobalPointerValues = */ {
#define CDAC_GLOBAL_POINTER(name,value) { /* .Name = */ GET_GLOBAL_NAME(name), /* .PointerDataIndex = */ GET_GLOBAL_POINTER_INDEX(name) },
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
},
/* .GlobalStringValues = */ {
#define CDAC_GLOBAL_STRING(name,value) { /* .Name = */ GET_GLOBAL_NAME(name), /* .Value = */ GET_GLOBALSTRING_VALUE(name) },
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
},
/* .NamesPool = */ ("\0" // starts with a nul
@@ -332,7 +312,7 @@ struct MagicAndBlob BlobDataDescriptor = {
#define CDAC_GLOBAL_STRING(name,value) #name "\0" STRINGIFY(value) "\0"
#define CDAC_GLOBAL_POINTER(name,value) #name "\0"
#define CDAC_GLOBAL(name,tyname,value) #name "\0" #tyname "\0"
-#include "datadescriptor.h"
+#include "wrappeddatadescriptor.inc"
),
/* .EndMagic = */ { 0x01, 0x02, 0x03, 0x04 },
diff --git a/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc b/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc
new file mode 100644
index 00000000000000..7500ac93388803
--- /dev/null
+++ b/src/coreclr/debug/datadescriptor-shared/wrappeddatadescriptor.inc
@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// No include guards. This file is included multiple times.
+// Wraps datadescriptor.inc to define and undefine macros used in the file.
+
+#ifndef CDAC_BASELINE
+#define CDAC_BASELINE(identifier)
+#endif
+#ifndef CDAC_TYPES_BEGIN
+#define CDAC_TYPES_BEGIN()
+#endif
+#ifndef CDAC_TYPE_BEGIN
+#define CDAC_TYPE_BEGIN(tyname)
+#endif
+#ifndef CDAC_TYPE_SIZE
+#define CDAC_TYPE_SIZE(k)
+#endif
+#ifndef CDAC_TYPE_INDETERMINATE
+#define CDAC_TYPE_INDETERMINATE(tyname)
+#endif
+#ifndef CDAC_TYPE_FIELD
+#define CDAC_TYPE_FIELD(tyname,fieldtyname,fieldname,off)
+#endif
+#ifndef CDAC_TYPE_END
+#define CDAC_TYPE_END(tyname)
+#endif
+#ifndef CDAC_TYPES_END
+#define CDAC_TYPES_END()
+#endif
+#ifndef CDAC_GLOBALS_BEGIN
+#define CDAC_GLOBALS_BEGIN()
+#endif
+#ifndef CDAC_GLOBAL
+#define CDAC_GLOBAL(globalname,tyname,val)
+#endif
+#ifndef CDAC_GLOBAL_POINTER
+#define CDAC_GLOBAL_POINTER(globalname,addr)
+#endif
+#ifndef CDAC_GLOBAL_STRING
+#define CDAC_GLOBAL_STRING(globalname,stringval)
+#endif
+#ifndef CDAC_GLOBALS_END
+#define CDAC_GLOBALS_END()
+#endif
+
+#include "datadescriptor.inc"
+
+#undef CDAC_BASELINE
+#undef CDAC_TYPES_BEGIN
+#undef CDAC_TYPE_BEGIN
+#undef CDAC_TYPE_INDETERMINATE
+#undef CDAC_TYPE_SIZE
+#undef CDAC_TYPE_FIELD
+#undef CDAC_TYPE_END
+#undef CDAC_TYPES_END
+#undef CDAC_GLOBALS_BEGIN
+#undef CDAC_GLOBAL
+#undef CDAC_GLOBAL_POINTER
+#undef CDAC_GLOBAL_STRING
+#undef CDAC_GLOBALS_END
diff --git a/src/coreclr/debug/di/cordb.cpp b/src/coreclr/debug/di/cordb.cpp
index d7d3957ec7db26..9f93d0bcfd6dfe 100644
--- a/src/coreclr/debug/di/cordb.cpp
+++ b/src/coreclr/debug/di/cordb.cpp
@@ -32,10 +32,9 @@
//-----------------------------------------------------------------------------
// In v1.0, we declared that mscordbi was a "shared" component, which means
// that we promised to provide it from now until the end of time. So every CLR implementation
-// needs an Mscordbi that implements the everett guids for CorDebug + CorPublish.
+// needs an Mscordbi that implements the everett guids for CorDebug
//
-// This works fine for CorPublish, which is truly shared.
-// CorDebug however is "versioned" not "shared" - each version of the CLR has its own disjoint copy.
+// CorDebug is "versioned" not "shared" - each version of the CLR has its own disjoint copy.
//
// Thus creating a CorDebug object requires a version parameter.
// CoCreateInstance doesn't have a the version param, so we use the new (v2.0+)
@@ -307,14 +306,6 @@ STDAPI DLLEXPORT DllGetClassObjectInternal( // Return code.
CClassFactory *pClassFactory; // To create class factory object.
PFN_CREATE_OBJ pfnCreateObject = NULL;
-
-#if defined(FEATURE_DBG_PUBLISH)
- if (rclsid == CLSID_CorpubPublish)
- {
- pfnCreateObject = CorpubPublish::CreateObject;
- }
- else
-#endif
#if defined(FEATURE_DBGIPC_TRANSPORT_DI)
if (rclsid == CLSID_CorDebug_Telesto)
{
diff --git a/src/coreclr/debug/di/module.cpp b/src/coreclr/debug/di/module.cpp
index 952f3fd71bd86c..b2736c8b4b8109 100644
--- a/src/coreclr/debug/di/module.cpp
+++ b/src/coreclr/debug/di/module.cpp
@@ -27,7 +27,7 @@ CordbModule::CordbModule(
CordbProcess * pProcess,
VMPTR_Module vmModule,
VMPTR_DomainAssembly vmDomainAssembly)
-: CordbBase(pProcess, vmDomainAssembly.IsNull() ? VmPtrToCookie(vmModule) : VmPtrToCookie(vmDomainAssembly), enumCordbModule),
+: CordbBase(pProcess, VmPtrToCookie(vmModule), enumCordbModule),
m_pAssembly(0),
m_pAppDomain(0),
m_classes(11),
diff --git a/src/coreclr/debug/di/process.cpp b/src/coreclr/debug/di/process.cpp
index 28de989969e501..57e436c006300d 100644
--- a/src/coreclr/debug/di/process.cpp
+++ b/src/coreclr/debug/di/process.cpp
@@ -5061,6 +5061,23 @@ void CordbProcess::RawDispatchEvent(
case DB_IPCE_LOAD_MODULE:
{
+ LOG((LF_CORDB, LL_INFO100,
+ "RCET::HRCE: load module (includes assembly loading) on thread %#x Asm:0x%08x AD:0x%08x \n",
+ dwVolatileThreadId,
+ VmPtrToCookie(pEvent->LoadModuleData.vmDomainAssembly),
+ VmPtrToCookie(pEvent->vmAppDomain)));
+
+ _ASSERTE (pAppDomain != NULL);
+
+ // Determine if this Assembly is cached.
+ CordbAssembly * pAssembly = pAppDomain->LookupOrCreateAssembly(pEvent->LoadModuleData.vmDomainAssembly);
+ _ASSERTE(pAssembly != NULL); // throws on error
+
+ // If created, or have, an Assembly, notify callback.
+ {
+ PUBLIC_CALLBACK_IN_THIS_SCOPE(this, pLockHolder, pEvent);
+ hr = pCallback1->LoadAssembly(pAppDomain, pAssembly);
+ }
_ASSERTE (pAppDomain != NULL);
CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->LoadModuleData.vmDomainAssembly);
@@ -5375,29 +5392,6 @@ void CordbProcess::RawDispatchEvent(
break;
- case DB_IPCE_LOAD_ASSEMBLY:
- {
- LOG((LF_CORDB, LL_INFO100,
- "RCET::HRCE: load assembly on thread %#x Asm:0x%08x AD:0x%08x \n",
- dwVolatileThreadId,
- VmPtrToCookie(pEvent->AssemblyData.vmDomainAssembly),
- VmPtrToCookie(pEvent->vmAppDomain)));
-
- _ASSERTE (pAppDomain != NULL);
-
- // Determine if this Assembly is cached.
- CordbAssembly * pAssembly = pAppDomain->LookupOrCreateAssembly(pEvent->AssemblyData.vmDomainAssembly);
- _ASSERTE(pAssembly != NULL); // throws on error
-
- // If created, or have, an Assembly, notify callback.
- {
- PUBLIC_CALLBACK_IN_THIS_SCOPE(this, pLockHolder, pEvent);
- hr = pCallback1->LoadAssembly(pAppDomain, pAssembly);
- }
- }
-
- break;
-
case DB_IPCE_UNLOAD_ASSEMBLY:
{
LOG((LF_CORDB, LL_INFO100, "RCET::DRCE: unload assembly on thread %#x Asm:0x%x AD:0x%x\n",
@@ -13281,9 +13275,9 @@ void CordbProcess::HandleDebugEventForInteropDebugging(const DEBUG_EVENT * pEven
LOG((LF_CORDB, LL_INFO100000, "W32ET::W32EL: hijack complete will restore context...\n"));
DT_CONTEXT tempContext = { 0 };
#if defined(DT_CONTEXT_EXTENDED_REGISTERS)
- tempContext.ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_EXTENDED_REGISTERS;
+ tempContext.ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_FLOATING_POINT | DT_CONTEXT_EXTENDED_REGISTERS;
#else
- tempContext.ContextFlags = DT_CONTEXT_FULL;
+ tempContext.ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_FLOATING_POINT;
#endif
HRESULT hr = pUnmanagedThread->GetThreadContext(&tempContext);
_ASSERTE(SUCCEEDED(hr));
@@ -15246,7 +15240,10 @@ CordbClass * CordbProcess::LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_Do
if (pAppDomain != NULL)
{
- CordbModule * pModule = ((CordbAppDomain *)pAppDomain)->m_modules.GetBase(VmPtrToCookie(vmDomainAssembly));
+ VMPTR_Module vmModule = VMPTR_Module::NullPtr();
+ GetProcess()->GetDAC()->GetModuleForDomainAssembly(vmDomainAssembly, &vmModule);
+ _ASSERTE(!vmModule.IsNull());
+ CordbModule * pModule = ((CordbAppDomain *)pAppDomain)->m_modules.GetBase(VmPtrToCookie(vmModule));
if (pModule != NULL)
{
return pModule->LookupClass(classToken);
diff --git a/src/coreclr/debug/di/publish.cpp b/src/coreclr/debug/di/publish.cpp
deleted file mode 100644
index 0a7bad24642885..00000000000000
--- a/src/coreclr/debug/di/publish.cpp
+++ /dev/null
@@ -1,1198 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//*****************************************************************************
-// File: publish.cpp
-//
-
-//
-//*****************************************************************************
-
-
-#include "stdafx.h"
-#ifdef FEATURE_DBG_PUBLISH
-
-#include "check.h"
-
-#include
-
-#ifndef SM_REMOTESESSION
-#define SM_REMOTESESSION 0x1000
-#endif
-
-#include "corpriv.h"
-#include "../../dlls/mscorrc/resource.h"
-#include
-
-// Publish shares header files with the rest of ICorDebug.
-// ICorDebug should not call ReadProcessMemory & other APIs directly, it should instead go through
-// the Data-target. ICD headers #define these APIs to help enforce this.
-// Since Publish is separate and doesn't use data-targets, it can access the APIs directly.
-// see code:RSDebuggingInfo#UseDataTarget
-#undef ReadProcessMemory
-
-//****************************************************************************
-//************ App Domain Publishing Service API Implementation **************
-//****************************************************************************
-
-// This function enumerates all the process in the system and returns
-// their PIDs
-BOOL GetAllProcessesInSystem(DWORD *ProcessId,
- DWORD dwArraySize,
- DWORD *pdwNumEntries)
-{
- HandleHolder hSnapshotHolder;
-
- // Create the Process' Snapshot
- HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
- if (hSnapshot == INVALID_HANDLE_VALUE)
- {
- LOG((LF_CORDB, LL_INFO1000,
- "Unable to create snapshot of processes in the system. "
- "CreateToolhelp32Snapshot() failed.\n"));
- return FALSE;
- }
- // HandleHolder doesn't deal with INVALID_HANDLE_VALUE, so we only assign if we have a legal value.
- hSnapshotHolder.Assign(hSnapshot);
-
- PROCESSENTRY32 PE32;
-
- // need to initialize the dwSize field before calling Process32First
- PE32.dwSize = sizeof (PROCESSENTRY32);
-
- // Get the first process in the process list
- BOOL succ = Process32First(hSnapshot, &PE32);
- if (succ != TRUE)
- {
- LOG((LF_CORDB, LL_INFO1000,
- "Unable to create snapshot of processes in the system. "
- "Process32First() returned FALSE.\n"));
- return FALSE;
- }
-
- // Loop over and get all the remaining processes
- int iIndex = 0;
-
- do
- {
- ProcessId [iIndex++] = PE32.th32ProcessID;
-
- succ = Process32Next(hSnapshot, &PE32);
-
- } while ((succ == TRUE) && (iIndex < (int)dwArraySize));
-
- _ASSERTE (iIndex < (int)dwArraySize);
-
- *pdwNumEntries = iIndex;
-
- // If we made it this far, we succeeded
- return TRUE;
-}
-
-
-// We never want to wait infinite on an object that we can't verify.
-// Wait with a timeout.
-const DWORD SAFETY_TIMEOUT = 2000;
-
-// ******************************************
-// CorpubPublish
-// ******************************************
-
-CorpubPublish::CorpubPublish()
- : CordbCommonBase(0)
- , m_fpGetModuleFileNameEx(NULL)
-{
- // Try to get psapi!GetModuleFileNameExW once, and then every process object can use it.
- // If we can't get it, then we'll fallback to getting information from the IPC block.
- m_hPSAPIdll = WszLoadLibrary(W("api-ms-win-obsolete-psapi-l1-1-0.dll"));
-
- if (m_hPSAPIdll != NULL)
- {
- m_fpGetModuleFileNameEx = (FPGetModuleFileNameEx*) GetProcAddress(m_hPSAPIdll, "GetModuleFileNameExW");
- }
-
- CordbCommonBase::InitializeCommon();
-}
-
-CorpubPublish::~CorpubPublish()
-{
- // m_hPSAPIdll is a module holder, so the dtor will free it automatically for us.
-}
-
-
-COM_METHOD CorpubPublish::QueryInterface(REFIID id, void **ppInterface)
-{
- if (id == IID_ICorPublish)
- *ppInterface = (ICorPublish*)this;
- else if (id == IID_IUnknown)
- *ppInterface = (IUnknown*)(ICorPublish*)this;
- else
- {
- *ppInterface = NULL;
- return E_NOINTERFACE;
- }
-
- ExternalAddRef();
- return S_OK;
-}
-
-
-COM_METHOD CorpubPublish::EnumProcesses(COR_PUB_ENUMPROCESS Type,
- ICorPublishProcessEnum **ppIEnum)
-{
- HRESULT hr = E_FAIL;
- CorpubProcess* pProcessList = NULL ;
- CorpubProcessEnum* pProcEnum = NULL;
- *ppIEnum = NULL;
-
- if( Type != COR_PUB_MANAGEDONLY )
- {
- hr = E_INVALIDARG;
- goto exit;
- }
-
- // call function to get PIDs for all processes in the system
-#define MAX_PROCESSES 512
-
- DWORD ProcessId[MAX_PROCESSES];
- DWORD dwNumProcesses = 0;
- if( !GetAllProcessesInSystem(ProcessId, MAX_PROCESSES, &dwNumProcesses) )
- {
- hr = E_FAIL;
- goto exit;
- }
-
- // iterate over all the processes to fetch all the managed processes
- for (int i = 0; i < (int)dwNumProcesses; i++)
- {
- CorpubProcess *pProcess = NULL;
- hr = GetProcessInternal( ProcessId[i], &pProcess );
- if( FAILED(hr) )
- {
- _ASSERTE( pProcess == NULL );
- goto exit; // a serious error has occurred, abort
- }
-
- if( hr == S_OK )
- {
- // Success, Add the process to the list.
- _ASSERTE( pProcess != NULL );
- pProcess->SetNext( pProcessList );
- pProcessList = pProcess;
- }
- else
- {
- // Ignore this process (isn't managed, or shut down, etc.)
- _ASSERTE( pProcess == NULL );
- }
- }
-
- // create and return the ICorPublishProcessEnum
- pProcEnum = new (nothrow) CorpubProcessEnum(pProcessList);
- if (pProcEnum == NULL)
- {
- hr = E_OUTOFMEMORY;
- goto exit;
- }
- pProcEnum->AddRef();
-
- hr = pProcEnum->QueryInterface(IID_ICorPublishProcessEnum, (void**)ppIEnum);
- if( FAILED(hr) )
- {
- goto exit;
- }
-
- hr = S_OK;
-
-exit:
- // release our handle on the process objects
- while (pProcessList != NULL)
- {
- CorpubProcess *pTmp = pProcessList;
- pProcessList = pProcessList->GetNextProcess();
- pTmp->Release();
- }
- if( pProcEnum != NULL )
- {
- pProcEnum->Release();
- pProcEnum = NULL;
- }
-
- return hr;
-}
-
-
-HRESULT CorpubPublish::GetProcess(unsigned pid,
- ICorPublishProcess **ppProcess)
-{
- *ppProcess = NULL;
-
- // Query for this specific process (even if we've already handed out a
- // now-stale process object for this pid)
- CorpubProcess * pProcess = NULL;
- HRESULT hr = GetProcessInternal( pid, &pProcess );
- if( hr != S_OK )
- {
- // Couldn't get this process (doesn't exist, or isn't managed)
- _ASSERTE( pProcess == NULL );
- if( FAILED(hr) )
- {
- return hr; // there was a serious error trying to get this process info
- }
- return E_INVALIDARG; // this process doesn't exist, isn't managed or is shutting down
- }
-
- // QI to ICorPublishProcess and return it
- _ASSERTE( pProcess != NULL );
- hr = pProcess->QueryInterface(IID_ICorPublishProcess, (void**)ppProcess);
- pProcess->Release();
- return hr;
-}
-
-
-// Attempts to create a CorpubProcess object for a specific managed process
-// On success returns S_OK and sets ppProcess to a new AddRef'd CorpubProcess
-// object. Otherwise, returns S_FALSE if the process isn't managed or if it has
-// terminated (i.e. it should be ignored), or and error code on a serious failure.
-HRESULT CorpubPublish::GetProcessInternal(
- unsigned pid,
- CorpubProcess **ppProcess )
-{
-#if defined(FEATURE_DBGIPC_TRANSPORT_DI)
- return E_NOTIMPL;
-
-#else // !FEATURE_DBGIPC_TRANSPORT_DI
- HRESULT hr = S_OK;
- *ppProcess = NULL;
-
- NewHolder pIPCReader( new (nothrow) IPCReaderInterface() );
- if (pIPCReader == NULL)
- {
- LOG((LF_CORDB, LL_INFO100, "CP::EP: Failed to allocate memory for IPCReaderInterface.\n"));
- return E_OUTOFMEMORY;
- }
-
- // See if it is a managed process by trying to open the shared
- // memory block.
- hr = pIPCReader->OpenLegacyPrivateBlockTempV4OnPid(pid);
- if (FAILED(hr))
- {
- return S_FALSE; // Not a managed process
- }
-
- // Get the AppDomainIPCBlock
- AppDomainEnumerationIPCBlock *pAppDomainCB = pIPCReader->GetAppDomainBlock();
- if (pAppDomainCB == NULL)
- {
- LOG((LF_CORDB, LL_INFO1000, "CP::EP: Failed to obtain AppDomainIPCBlock.\n"));
- return S_FALSE;
- }
-
- // Get the process handle.
- HANDLE hProcess = OpenProcess((PROCESS_VM_READ |
- PROCESS_QUERY_INFORMATION |
- PROCESS_DUP_HANDLE |
- SYNCHRONIZE),
- FALSE, pid);
- if (hProcess == NULL)
- {
- LOG((LF_CORDB, LL_INFO1000, "CP::EP: OpenProcess() returned NULL handle.\n"));
- return S_FALSE;
- }
-
- // If the mutex isn't filled in, the CLR is either starting up or shutting down
- if (pAppDomainCB->m_hMutex == NULL)
- {
- LOG((LF_CORDB, LL_INFO1000, "CP::EP: IPC block isn't properly filled in.\n"));
- return S_FALSE;
- }
-
- // Dup the valid mutex handle into this process.
- HANDLE hMutex;
- if( !pAppDomainCB->m_hMutex.DuplicateToLocalProcess(hProcess, &hMutex) )
- {
- return S_FALSE;
- }
-
- // Acquire the mutex, only waiting two seconds.
- // We can't actually guarantee that the target put a mutex object in here.
- DWORD dwRetVal = WaitForSingleObject(hMutex, SAFETY_TIMEOUT);
-
- if (dwRetVal == WAIT_OBJECT_0)
- {
- // Make sure the mutex handle is still valid. If
- // its not, then we lost a shutdown race.
- if (pAppDomainCB->m_hMutex == NULL)
- {
- LOG((LF_CORDB, LL_INFO1000, "CP::EP: lost shutdown race, skipping...\n"));
-
- ReleaseMutex(hMutex);
- CloseHandle(hMutex);
- return S_FALSE;
- }
- }
- else
- {
- // Again, landing here is most probably a shutdown race. Its okay, though...
- LOG((LF_CORDB, LL_INFO1000, "CP::EP: failed to get IPC mutex.\n"));
-
- if (dwRetVal == WAIT_ABANDONED)
- {
- ReleaseMutex(hMutex);
- }
- CloseHandle(hMutex);
- return S_FALSE;
- }
- // Beware: if the target pid is not properly honoring the mutex, the data in the
- // IPC block may still shift underneath us.
-
- // If we get here, then hMutex is held by this process.
-
- // Now create the CorpubProcess object for the ProcessID
- CorpubProcess *pProc = new (nothrow) CorpubProcess(pid,
- true,
- hProcess,
- hMutex,
- pAppDomainCB,
- pIPCReader,
- m_fpGetModuleFileNameEx);
-
- // Release our lock on the IPC block.
- ReleaseMutex(hMutex);
-
- if (pProc == NULL)
- {
- return E_OUTOFMEMORY;
- }
- pIPCReader.SuppressRelease();
-
- // Success, return the Process object
- pProc->AddRef();
- *ppProcess = pProc;
- return S_OK;
-
-#endif // FEATURE_DBGIPC_TRANSPORT_DI
-}
-
-
-
-// ******************************************
-// CorpubProcess
-// ******************************************
-
-// Constructor
-CorpubProcess::CorpubProcess(DWORD dwProcessId,
- bool fManaged,
- HANDLE hProcess,
- HANDLE hMutex,
- AppDomainEnumerationIPCBlock *pAD,
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI)
- IPCReaderInterface *pIPCReader,
-#endif // !FEATURE_DBGIPC_TRANSPORT_DI
- FPGetModuleFileNameEx * fpGetModuleFileNameEx)
- : CordbCommonBase(0, enumCorpubProcess),
- m_dwProcessId(dwProcessId),
- m_fIsManaged(fManaged),
- m_hProcess(hProcess),
- m_hMutex(hMutex),
- m_AppDomainCB(pAD),
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI)
- m_pIPCReader(pIPCReader),
-#endif // !FEATURE_DBGIPC_TRANSPORT_DI
- m_pNext(NULL)
-{
- {
- // First try to get the process name from the OS. That can't be spoofed by badly formed IPC block.
- // psapi!GetModuleFileNameExW can get that, but it's not available on all platforms so we
- // need to load it dynamically.
- if (fpGetModuleFileNameEx != NULL)
- {
- // MSDN is very confused about whether the length is in bytes (MSDN 2002) or chars (MSDN 2004).
- // We err on the safe side by having buffer that's twice as large, and ignoring
- // the units on the return value.
- WCHAR szName[MAX_LONGPATH * sizeof(WCHAR)];
-
- DWORD lenInCharsOrBytes = MAX_LONGPATH*sizeof(WCHAR);
-
- // Pass NULL module handle to get "Main Module", which will give us the process name.
- DWORD ret = (*fpGetModuleFileNameEx) (hProcess, NULL, szName, lenInCharsOrBytes);
- if (ret > 0)
- {
- // Recompute string length because we don't know if 'ret' is in bytes or char.
- SIZE_T len = u16_strlen(szName) + 1;
- m_szProcessName = new (nothrow) WCHAR[len];
- if (m_szProcessName != NULL)
- {
- wcscpy_s(m_szProcessName, len, szName);
- goto exit;
- }
- }
- }
-
- // This is a security feature on WinXp + above, so make sure it worked there.
- CONSISTENCY_CHECK_MSGF(FALSE, ("On XP/2k03 OSes + above, we should have been able to get\n"
- "the module name from psapi!GetModuleFileNameEx. fp=0x%p\n.", fpGetModuleFileNameEx));
- }
- // We couldn't get it from the OS, so fallthrough to getting it from the IPC block.
-
- // Fetch the process name from the AppDomainIPCBlock
- _ASSERTE (pAD->m_szProcessName != NULL);
-
- if (pAD->m_szProcessName == NULL)
- m_szProcessName = NULL;
- else
- {
- SIZE_T nBytesRead;
-
- _ASSERTE(pAD->m_iProcessNameLengthInBytes > 0);
-
- // Note: this assumes we're reading the null terminator from
- // the IPC block.
- m_szProcessName = (WCHAR*) new (nothrow) char[pAD->m_iProcessNameLengthInBytes];
-
- if (m_szProcessName == NULL)
- {
- LOG((LF_CORDB, LL_INFO1000,
- "CP::CP: Failed to allocate memory for ProcessName.\n"));
-
- goto exit;
- }
-
- BOOL bSucc = ReadProcessMemory(hProcess,
- pAD->m_szProcessName,
- m_szProcessName,
- pAD->m_iProcessNameLengthInBytes,
- &nBytesRead);
-
- if ((bSucc == 0) ||
- (nBytesRead != (SIZE_T)pAD->m_iProcessNameLengthInBytes))
- {
- // The EE may have done a rude exit
- LOG((LF_CORDB, LL_INFO1000,
- "CP::EAD: ReadProcessMemory (ProcessName) failed.\n"));
- }
- }
-
-exit:
- ;
-}
-
-CorpubProcess::~CorpubProcess()
-{
- delete [] m_szProcessName;
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI)
- delete m_pIPCReader;
-#endif // !FEATURE_DBGIPC_TRANSPORT_DI
- CloseHandle(m_hProcess);
- CloseHandle(m_hMutex);
-}
-
-
-HRESULT CorpubProcess::QueryInterface(REFIID id, void **ppInterface)
-{
- if (id == IID_ICorPublishProcess)
- *ppInterface = (ICorPublishProcess*)this;
- else if (id == IID_IUnknown)
- *ppInterface = (IUnknown*)(ICorPublishProcess*)this;
- else
- {
- *ppInterface = NULL;
- return E_NOINTERFACE;
- }
-
- AddRef();
- return S_OK;
-}
-
-
-// Helper to tell if this process has exited.
-bool CorpubProcess::IsExited()
-{
- DWORD res = WaitForSingleObject(this->m_hProcess, 0);
- return (res == WAIT_OBJECT_0);
-}
-
-
-HRESULT CorpubProcess::IsManaged(BOOL *pbManaged)
-{
- *pbManaged = (m_fIsManaged == true) ? TRUE : FALSE;
-
- return S_OK;
-}
-
-// Helper.
-// Allocates a local buffer (using 'new') and fills it by copying it from remote memory.
-// Returns:
-// - on success, S_OK, *ppNewLocalBuffer points to a newly allocated buffer containing
-// the full copy from remote memoy. Caller must use 'delete []' to free this.
-// - on failure, a failing HR. No memory is allocated.
-HRESULT AllocateAndReadRemoteBuffer(
- HANDLE hProcess,
- void * pRemotePtr,
- SIZE_T cbSize, // size of buffer to allocate + copy.
- BYTE * * ppNewLocalBuffer
-)
-{
- _ASSERTE(ppNewLocalBuffer != NULL);
- *ppNewLocalBuffer = NULL;
-
-
- if (pRemotePtr == NULL)
- {
- return E_INVALIDARG;
- }
-
- BYTE *pLocalBuffer = new (nothrow) BYTE[cbSize];
-
- if (pLocalBuffer == NULL)
- {
- _ASSERTE(!"Failed to alloc memory. Likely size is bogusly large, perhaps from an attacker.");
- return E_OUTOFMEMORY;
- }
-
- SIZE_T nBytesRead;
-
- // Need to read in the remote process' memory
- BOOL bSucc = ReadProcessMemory(hProcess,
- pRemotePtr,
- pLocalBuffer, cbSize,
- &nBytesRead);
-
- if ((bSucc == 0) || (nBytesRead != cbSize))
- {
- // The EE may have done a rude exit
- delete [] pLocalBuffer;
- return E_FAIL;
- }
-
- *ppNewLocalBuffer = pLocalBuffer;
- return S_OK;
-}
-
-// Wrapper around AllocateAndReadRemoteBuffer,
-// to ensure that we're reading an remote-null terminated string.
-// Ensures that string is null-terminated.
-HRESULT AllocateAndReadRemoteString(
- HANDLE hProcess,
- void * pRemotePtr,
- SIZE_T cbSize, // size of buffer to allocate + copy.
- _Outptr_result_bytebuffer_(cbSize) WCHAR * * ppNewLocalBuffer
- )
-{
- // Make sure buffer has right geometry.
- if (cbSize < 0)
- {
- return E_INVALIDARG;
- }
-
- // If it's not on a WCHAR boundary, then we may have a 1-byte buffer-overflow.
- SIZE_T ceSize = cbSize / sizeof(WCHAR);
- if ((ceSize * sizeof(WCHAR)) != cbSize)
- {
- return E_INVALIDARG;
- }
-
- // It should at least have 1 char for the null terminator.
- if (ceSize < 1)
- {
- return E_INVALIDARG;
- }
-
-
- HRESULT hr = AllocateAndReadRemoteBuffer(hProcess, pRemotePtr, cbSize, (BYTE**) ppNewLocalBuffer);
- if (SUCCEEDED(hr))
- {
- // Ensure that the string we just read is actually null terminated.
- // We can't call u16_strlen() on it yet, since that may AV on a non-null terminated string.
- WCHAR * pString = *ppNewLocalBuffer;
-
- if (pString[ceSize - 1] == W('\0'))
- {
- // String is null terminated.
- return S_OK;
- }
- pString[ceSize - 1] = W('\0');
-
- SIZE_T ceTestLen = u16_strlen(pString);
- if (ceTestLen == ceSize - 1)
- {
- // String was not previously null-terminated.
- delete [] ppNewLocalBuffer;
- return E_INVALIDARG;
- }
- }
- return S_OK;
-}
-
-//
-// Enumerate the list of known application domains in the target process.
-//
-HRESULT CorpubProcess::EnumAppDomains(ICorPublishAppDomainEnum **ppIEnum)
-{
- VALIDATE_POINTER_TO_OBJECT(ppIEnum, ICorPublishAppDomainEnum **);
- *ppIEnum = NULL;
-
- int i;
-
- HRESULT hr = S_OK;
- WCHAR *pAppDomainName = NULL;
- CorpubAppDomain *pAppDomainHead = NULL;
-
- // Lock the IPC block:
- // We can't trust any of the data in the IPC block (including our own mutex handle),
- // because we don't want bugs in the debuggee escalating into bugs in the debugger.
- DWORD res = WaitForSingleObject(m_hMutex, SAFETY_TIMEOUT);
-
- if (res == WAIT_TIMEOUT)
- {
- // This should only happen if the target process is illbehaved.
- return CORDBG_E_TIMEOUT;
- }
-
- // If the process has gone away, or if it has cleared out its control block, then
- // we've lost the race to access this process before it is terminated.
- // Note that if the EE does a rude process exit, it won't have cleared the control block so there
- // will be a small race window.
- if (this->IsExited() || this->m_AppDomainCB->m_hMutex == NULL )
- {
- // This is the common case. A process holding the mutex shouldn't normally exit,
- // but once it releases the mutex, it may exit asynchronously.
- return CORDBG_E_PROCESS_TERMINATED;
- }
-
- if (res == WAIT_FAILED)
- {
- // This should be the next most common failure case
- return HRESULT_FROM_GetLastError();
- }
-
- if (res != WAIT_OBJECT_0)
- {
- // Catch all other possible failures
- return E_FAIL;
- }
-
- int iAppDomainCount = 0;
- AppDomainInfo *pADI = NULL;
-
- // Make a copy of the IPC block so that we can guarantee that it's not changing on us.
- AppDomainEnumerationIPCBlock tempBlock;
- memcpy(&tempBlock, m_AppDomainCB, sizeof(tempBlock));
-
- // Allocate memory to read the remote process' memory into
- const SIZE_T cbADI = tempBlock.m_iSizeInBytes;
-
- // It's possible the process will not have any appdomains.
- if ((tempBlock.m_rgListOfAppDomains == NULL) != (tempBlock.m_iSizeInBytes == 0))
- {
- _ASSERTE(!"Inconsistent IPC block in publish.");
- hr = E_FAIL;
- goto exit;
- }
-
- // All the data in the IPC block is signed integers. They should never be negative,
- // so check that now.
- if ((tempBlock.m_iTotalSlots < 0) ||
- (tempBlock.m_iNumOfUsedSlots < 0) ||
- (tempBlock.m_iLastFreedSlot < 0) ||
- (tempBlock.m_iSizeInBytes < 0) ||
- (tempBlock.m_iProcessNameLengthInBytes < 0))
- {
- hr = E_FAIL;
- goto exit;
- }
-
- // Check other invariants.
- if (cbADI != tempBlock.m_iTotalSlots * sizeof(AppDomainInfo))
- {
- _ASSERTE(!"Size mismatch");
- hr = E_FAIL;
- goto exit;
- }
-
- hr = AllocateAndReadRemoteBuffer(m_hProcess, tempBlock.m_rgListOfAppDomains, cbADI, (BYTE**) &pADI);
- if (FAILED(hr))
- {
- goto exit;
- }
- _ASSERTE(pADI != NULL);
-
- // Collect all the AppDomain info info a list of CorpubAppDomains
- for (i = 0; i < tempBlock.m_iTotalSlots; i++)
- {
- if (!pADI[i].IsEmpty())
- {
- // Should be positive, and at least have a null-terminator character.
- if (pADI[i].m_iNameLengthInBytes <= 1)
- {
- hr = E_INVALIDARG;
- goto exit;
- }
- hr = AllocateAndReadRemoteString(m_hProcess,
- (void*) pADI[i].m_szAppDomainName, pADI[i].m_iNameLengthInBytes, // remote string + size in bytes
- &pAppDomainName);
- if (FAILED(hr))
- {
- goto exit;
- }
-
- // create a new AppDomainObject. This will take ownership of pAppDomainName.
- // We know the string is a well-formed null-terminated string,
- // but beyond that, we can't verify that the data is actually truthful.
- CorpubAppDomain *pCurrentAppDomain = new (nothrow) CorpubAppDomain(pAppDomainName,
- pADI[i].m_id);
-
- if (pCurrentAppDomain == NULL)
- {
- LOG((LF_CORDB, LL_INFO1000,
- "CP::EAD: Failed to allocate memory for CorpubAppDomain.\n"));
-
- hr = E_OUTOFMEMORY;
- goto exit;
- }
-
- // Since CorpubAppDomain now owns pAppDomain's memory, we don't worry about freeing it.
- pAppDomainName = NULL;
-
- // Add the appdomain to the list.
- pCurrentAppDomain->SetNext(pAppDomainHead);
- pAppDomainHead = pCurrentAppDomain;
-
- // Shortcut to opt out of reading the rest of the array if it's empty.
- if (++iAppDomainCount >= tempBlock.m_iNumOfUsedSlots)
- break;
- }
- }
-
- {
- _ASSERTE ((iAppDomainCount >= tempBlock.m_iNumOfUsedSlots)
- && (i <= tempBlock.m_iTotalSlots));
-
- // create and return the ICorPublishAppDomainEnum object, handing off the AppDomain list to it
- CorpubAppDomainEnum *pTemp = new (nothrow) CorpubAppDomainEnum(pAppDomainHead);
-
- if (pTemp == NULL)
- {
- hr = E_OUTOFMEMORY;
- goto exit;
- }
-
- pAppDomainHead = NULL; // handed off AppDomain list to enum, don't delete below
-
- hr = pTemp->QueryInterface(IID_ICorPublishAppDomainEnum,
- (void **)ppIEnum);
- }
-
-exit:
- ReleaseMutex(m_hMutex);
-
- // If we didn't hand off the AppDomain objects, delete them
- while( pAppDomainHead != NULL )
- {
- CorpubAppDomain *pTemp = pAppDomainHead;
- pAppDomainHead = pAppDomainHead->GetNextAppDomain();
- delete pTemp;
- }
-
- if (pADI != NULL)
- delete[] pADI;
-
- if (pAppDomainName != NULL)
- delete [] pAppDomainName;
-
- // Either we succeeded && provided an enumerator; or we failed and didn't provide an enum.
- _ASSERTE(SUCCEEDED(hr) == (*ppIEnum != NULL));
- return hr;
-}
-
-/*
- * Returns the OS ID for the process in question.
- */
-HRESULT CorpubProcess::GetProcessID(unsigned *pid)
-{
- *pid = m_dwProcessId;
-
- return S_OK;
-}
-
-/*
- * Get the display name for a process.
- */
-HRESULT CorpubProcess::GetDisplayName(ULONG32 cchName,
- ULONG32 *pcchName,
- _Out_writes_to_opt_(cchName, *pcchName) WCHAR szName[])
-{
- VALIDATE_POINTER_TO_OBJECT_ARRAY_OR_NULL(szName, WCHAR, cchName, true, true);
- VALIDATE_POINTER_TO_OBJECT_OR_NULL(pcchName, ULONG32 *);
-
- // Reasonable defaults
- if (szName)
- *szName = 0;
-
- if (pcchName)
- *pcchName = 0;
-
- const WCHAR *szTempName = m_szProcessName;
-
- // In case we didn't get the name (most likely out of memory on ctor).
- if (!szTempName)
- szTempName = W("");
-
- return CopyOutString(szTempName, cchName, pcchName, szName);
-}
-
-
-// ******************************************
-// CorpubAppDomain
-// ******************************************
-
-CorpubAppDomain::CorpubAppDomain (_In_ LPWSTR szAppDomainName, ULONG Id)
- : CordbCommonBase (0, enumCorpubAppDomain),
- m_pNext (NULL),
- m_szAppDomainName (szAppDomainName),
- m_id (Id)
-{
- _ASSERTE(m_szAppDomainName != NULL);
-}
-
-CorpubAppDomain::~CorpubAppDomain()
-{
- delete [] m_szAppDomainName;
-}
-
-HRESULT CorpubAppDomain::QueryInterface (REFIID id, void **ppInterface)
-{
- if (id == IID_ICorPublishAppDomain)
- *ppInterface = (ICorPublishAppDomain*)this;
- else if (id == IID_IUnknown)
- *ppInterface = (IUnknown*)(ICorPublishAppDomain*)this;
- else
- {
- *ppInterface = NULL;
- return E_NOINTERFACE;
- }
-
- AddRef();
- return S_OK;
-}
-
-
-/*
- * Get the name and ID for an application domain.
- */
-HRESULT CorpubAppDomain::GetID (ULONG32 *pId)
-{
- VALIDATE_POINTER_TO_OBJECT(pId, ULONG32 *);
-
- *pId = m_id;
-
- return S_OK;
-}
-
-/*
- * Get the name for an application domain.
- */
-HRESULT CorpubAppDomain::GetName(ULONG32 cchName,
- ULONG32 *pcchName,
- _Out_writes_to_opt_(cchName, *pcchName) WCHAR szName[])
-{
- VALIDATE_POINTER_TO_OBJECT_ARRAY_OR_NULL(szName, WCHAR, cchName, true, true);
- VALIDATE_POINTER_TO_OBJECT_OR_NULL(pcchName, ULONG32 *);
-
- const WCHAR *szTempName = m_szAppDomainName;
-
- // In case we didn't get the name (most likely out of memory on ctor).
- if (!szTempName)
- szTempName = W("");
-
- return CopyOutString(szTempName, cchName, pcchName, szName);
-}
-
-
-
-// ******************************************
-// CorpubProcessEnum
-// ******************************************
-
-CorpubProcessEnum::CorpubProcessEnum (CorpubProcess *pFirst)
- : CordbCommonBase (0, enumCorpubProcessEnum),
- m_pFirst (pFirst),
- m_pCurrent (pFirst)
-{
- // Increment the ref count on each process, we own the list
- CorpubProcess * cur = pFirst;
- while( cur != NULL )
- {
- cur->AddRef();
- cur = cur->GetNextProcess();
- }
-}
-
-CorpubProcessEnum::~CorpubProcessEnum()
-{
- // Release each process in the list (our client may still have a reference
- // to some of them)
- while (m_pFirst != NULL)
- {
- CorpubProcess *pTmp = m_pFirst;
- m_pFirst = m_pFirst->GetNextProcess();
- pTmp->Release();
- }
-}
-
-HRESULT CorpubProcessEnum::QueryInterface (REFIID id, void **ppInterface)
-{
- if (id == IID_ICorPublishProcessEnum)
- *ppInterface = (ICorPublishProcessEnum*)this;
- else if (id == IID_IUnknown)
- *ppInterface = (IUnknown*)(ICorPublishProcessEnum*)this;
- else
- {
- *ppInterface = NULL;
- return E_NOINTERFACE;
- }
-
- AddRef();
- return S_OK;
-}
-
-
-HRESULT CorpubProcessEnum::Skip(ULONG celt)
-{
- while ((m_pCurrent != NULL) && (celt-- > 0))
- {
- m_pCurrent = m_pCurrent->GetNextProcess();
- }
-
- return S_OK;
-}
-
-HRESULT CorpubProcessEnum::Reset()
-{
- m_pCurrent = m_pFirst;
-
- return S_OK;
-}
-
-HRESULT CorpubProcessEnum::Clone(ICorPublishEnum **ppEnum)
-{
- VALIDATE_POINTER_TO_OBJECT(ppEnum, ICorPublishEnum **);
- return E_NOTIMPL;
-}
-
-HRESULT CorpubProcessEnum::GetCount(ULONG *pcelt)
-{
- VALIDATE_POINTER_TO_OBJECT(pcelt, ULONG *);
-
- CorpubProcess *pTemp = m_pFirst;
-
- *pcelt = 0;
-
- while (pTemp != NULL)
- {
- (*pcelt)++;
- pTemp = pTemp->GetNextProcess();
- }
-
- return S_OK;
-}
-
-HRESULT CorpubProcessEnum::Next(ULONG celt,
- ICorPublishProcess *objects[],
- ULONG *pceltFetched)
-{
- VALIDATE_POINTER_TO_OBJECT_ARRAY(objects, ICorPublishProcess *,
- celt, true, true);
- VALIDATE_POINTER_TO_OBJECT_OR_NULL(pceltFetched, ULONG *);
-
- if ((pceltFetched == NULL) && (celt != 1))
- {
- return E_INVALIDARG;
- }
-
- if (celt == 0)
- {
- if (pceltFetched != NULL)
- {
- *pceltFetched = 0;
- }
- return S_OK;
- }
-
- HRESULT hr = S_OK;
-
- ULONG count = 0;
-
- while ((m_pCurrent != NULL) && (count < celt))
- {
- hr = m_pCurrent->QueryInterface (IID_ICorPublishProcess,
- (void**)&objects[count]);
-
- if (hr != S_OK)
- {
- break;
- }
-
- count++;
- m_pCurrent = m_pCurrent->GetNextProcess();
- }
-
- if (pceltFetched != NULL)
- {
- *pceltFetched = count;
- }
-
- //
- // If we reached the end of the enumeration, but not the end
- // of the number of requested items, we return S_FALSE.
- //
- if (count < celt)
- {
- return S_FALSE;
- }
-
- return hr;
-}
-
-// ******************************************
-// CorpubAppDomainEnum
-// ******************************************
-CorpubAppDomainEnum::CorpubAppDomainEnum (CorpubAppDomain *pFirst)
- : CordbCommonBase (0, enumCorpubAppDomainEnum),
- m_pFirst (pFirst),
- m_pCurrent (pFirst)
-{
- CorpubAppDomain *pCur = pFirst;
- while( pCur != NULL )
- {
- pCur->AddRef();
- pCur = pCur->GetNextAppDomain();
- }
-}
-
-CorpubAppDomainEnum::~CorpubAppDomainEnum()
-{
- // Delete all the app domains
- while (m_pFirst != NULL )
- {
- CorpubAppDomain *pTemp = m_pFirst;
- m_pFirst = m_pFirst->GetNextAppDomain();
- pTemp->Release();
- }
-}
-
-HRESULT CorpubAppDomainEnum::QueryInterface (REFIID id, void **ppInterface)
-{
- if (id == IID_ICorPublishAppDomainEnum)
- *ppInterface = (ICorPublishAppDomainEnum*)this;
- else if (id == IID_IUnknown)
- *ppInterface = (IUnknown*)(ICorPublishAppDomainEnum*)this;
- else
- {
- *ppInterface = NULL;
- return E_NOINTERFACE;
- }
-
- AddRef();
- return S_OK;
-}
-
-
-HRESULT CorpubAppDomainEnum::Skip(ULONG celt)
-{
- while ((m_pCurrent != NULL) && (celt-- > 0))
- {
- m_pCurrent = m_pCurrent->GetNextAppDomain();
- }
-
- return S_OK;
-}
-
-HRESULT CorpubAppDomainEnum::Reset()
-{
- m_pCurrent = m_pFirst;
-
- return S_OK;
-}
-
-HRESULT CorpubAppDomainEnum::Clone(ICorPublishEnum **ppEnum)
-{
- VALIDATE_POINTER_TO_OBJECT(ppEnum, ICorPublishEnum **);
- return E_NOTIMPL;
-}
-
-HRESULT CorpubAppDomainEnum::GetCount(ULONG *pcelt)
-{
- VALIDATE_POINTER_TO_OBJECT(pcelt, ULONG *);
-
- CorpubAppDomain *pTemp = m_pFirst;
-
- *pcelt = 0;
-
- while (pTemp != NULL)
- {
- (*pcelt)++;
- pTemp = pTemp->GetNextAppDomain();
- }
-
- return S_OK;
-}
-
-HRESULT CorpubAppDomainEnum::Next(ULONG celt,
- ICorPublishAppDomain *objects[],
- ULONG *pceltFetched)
-{
- VALIDATE_POINTER_TO_OBJECT_ARRAY(objects, ICorPublishProcess *,
- celt, true, true);
- VALIDATE_POINTER_TO_OBJECT_OR_NULL(pceltFetched, ULONG *);
-
- if ((pceltFetched == NULL) && (celt != 1))
- {
- return E_INVALIDARG;
- }
-
- if (celt == 0)
- {
- if (pceltFetched != NULL)
- {
- *pceltFetched = 0;
- }
- return S_OK;
- }
-
- HRESULT hr = S_OK;
-
- ULONG count = 0;
-
- while ((m_pCurrent != NULL) && (count < celt))
- {
- hr = m_pCurrent->QueryInterface (IID_ICorPublishAppDomain,
- (void **)&objects[count]);
-
- if (hr != S_OK)
- {
- break;
- }
-
- count++;
- m_pCurrent = m_pCurrent->GetNextAppDomain();
- }
-
-
- if (pceltFetched != NULL)
- {
- *pceltFetched = count;
- }
-
- //
- // If we reached the end of the enumeration, but not the end
- // of the number of requested items, we return S_FALSE.
- //
- if (count < celt)
- {
- return S_FALSE;
- }
-
- return hr;
-}
-
-#endif // defined(FEATURE_DBG_PUBLISH)
diff --git a/src/coreclr/debug/di/rsappdomain.cpp b/src/coreclr/debug/di/rsappdomain.cpp
index dfc3c774ea7a18..a4a59d09ffbd77 100644
--- a/src/coreclr/debug/di/rsappdomain.cpp
+++ b/src/coreclr/debug/di/rsappdomain.cpp
@@ -834,15 +834,25 @@ CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_Module vmModule, VMPTR_D
_ASSERTE(!vmDomainAssembly.IsNull() || !vmModule.IsNull());
+ if (vmModule.IsNull())
+ GetProcess()->GetDAC()->GetModuleForDomainAssembly(vmDomainAssembly, &vmModule);
+
+ _ASSERTE(!vmModule.IsNull());
+
// check to see if the module is present in this app domain
- pModule = m_modules.GetBase(vmDomainAssembly.IsNull() ? VmPtrToCookie(vmModule) : VmPtrToCookie(vmDomainAssembly));
+ pModule = m_modules.GetBase(VmPtrToCookie(vmModule));
if (pModule != NULL)
{
return pModule;
}
- if (vmModule.IsNull())
- GetProcess()->GetDAC()->GetModuleForDomainAssembly(vmDomainAssembly, &vmModule);
+ if (vmDomainAssembly.IsNull())
+ {
+ // If we don't have a domain assembly, we can look it up from the module.
+ GetProcess()->GetDAC()->GetDomainAssemblyFromModule(vmModule, &vmDomainAssembly);
+ }
+
+ _ASSERTE(!vmDomainAssembly.IsNull());
RSInitHolder pModuleInit(new CordbModule(GetProcess(), vmModule, vmDomainAssembly));
pModule = pModuleInit.TransferOwnershipToHash(&m_modules);
diff --git a/src/coreclr/debug/di/rsmain.cpp b/src/coreclr/debug/di/rsmain.cpp
index 33c9e82878c30e..d34c84974a0bb7 100644
--- a/src/coreclr/debug/di/rsmain.cpp
+++ b/src/coreclr/debug/di/rsmain.cpp
@@ -452,7 +452,7 @@ void LeftSideResourceCleanupList::SweepNeuterLeftSideResources(CordbProcess * pP
* ------------------------------------------------------------------------- */
extern void* GetClrModuleBase();
-// Do any initialization necessary for both CorPublish and CorDebug
+// Do any initialization necessary for CorDebug
// This includes enabling logging and adding the SEDebug priv.
void CordbCommonBase::InitializeCommon()
{
diff --git a/src/coreclr/debug/di/rspriv.h b/src/coreclr/debug/di/rspriv.h
index d0be92394f1500..21a7703838f134 100644
--- a/src/coreclr/debug/di/rspriv.h
+++ b/src/coreclr/debug/di/rspriv.h
@@ -114,13 +114,6 @@ class CordbEval;
class CordbMDA;
-class CorpubPublish;
-class CorpubProcess;
-class CorpubAppDomain;
-class CorpubProcessEnum;
-class CorpubAppDomainEnum;
-
-
class RSLock;
class NeuterList;
@@ -1094,11 +1087,11 @@ typedef enum {
enumCordbEnCSnapshot, // 21
enumCordbEval, // 22
enumCordbUnmanagedThread,// 23
- enumCorpubPublish, // 24
- enumCorpubProcess, // 25
- enumCorpubAppDomain, // 26
- enumCorpubProcessEnum, // 27
- enumCorpubAppDomainEnum,// 28
+ // unused, // 24
+ // unused, // 25
+ // unused, // 26
+ // unused, // 27
+ // unused, // 28
enumCordbEnumFilter, // 29
enumCordbEnCErrorInfo, // 30
enumCordbEnCErrorInfoEnum,//31
@@ -1157,7 +1150,7 @@ class CordbHashTable;
#define CORDB_COMMON_BASE_SIGNATURE 0x0d00d96a
#define CORDB_COMMON_BASE_SIGNATURE_DEAD 0x0dead0b1
-// Common base for both CorPublish + CorDebug objects.
+// Common base for CorDebug objects.
class CordbCommonBase : public IUnknown
{
public:
@@ -10691,12 +10684,6 @@ class CordbUnmanagedThread : public CordbBase
};
#endif // FEATURE_INTEROP_DEBUGGING
-
-//********************************************************************************
-//**************** App Domain Publishing Service API *****************************
-//********************************************************************************
-
-
class EnumElement
{
public:
@@ -10716,293 +10703,6 @@ class EnumElement
EnumElement *m_pNext;
};
-#if defined(FEATURE_DBG_PUBLISH)
-
-// Prototype of psapi!GetModuleFileNameEx.
-typedef DWORD FPGetModuleFileNameEx(HANDLE, HMODULE, LPTSTR, DWORD);
-
-
-class CorpubPublish : public CordbCommonBase, public ICorPublish
-{
-public:
- CorpubPublish();
- virtual ~CorpubPublish();
-
-#ifdef _DEBUG
- virtual const char * DbgGetName() { return "CordbPublish"; }
-#endif
-
- //-----------------------------------------------------------
- // IUnknown
- //-----------------------------------------------------------
-
- ULONG STDMETHODCALLTYPE AddRef()
- {
- return (BaseAddRef());
- }
- ULONG STDMETHODCALLTYPE Release()
- {
- return (BaseRelease());
- }
- COM_METHOD QueryInterface(REFIID riid, void **ppInterface);
-
- //-----------------------------------------------------------
- // ICorPublish
- //-----------------------------------------------------------
-
- COM_METHOD EnumProcesses(
- COR_PUB_ENUMPROCESS Type,
- ICorPublishProcessEnum **ppIEnum);
-
- COM_METHOD GetProcess(
- unsigned pid,
- ICorPublishProcess **ppProcess);
-
- //-----------------------------------------------------------
- // CreateObject
- //-----------------------------------------------------------
- static COM_METHOD CreateObject(REFIID id, void **object)
- {
- *object = NULL;
-
- if (id != IID_IUnknown && id != IID_ICorPublish)
- return (E_NOINTERFACE);
-
- CorpubPublish *pCorPub = new (nothrow) CorpubPublish();
-
- if (pCorPub == NULL)
- return (E_OUTOFMEMORY);
-
- *object = (ICorPublish*)pCorPub;
- pCorPub->AddRef();
-
- return (S_OK);
- }
-
-private:
- HRESULT GetProcessInternal( unsigned pid, CorpubProcess **ppProcess );
-
- // Cached information to get the process name. Not available on all platforms, so may be null.
- HModuleHolder m_hPSAPIdll;
- FPGetModuleFileNameEx * m_fpGetModuleFileNameEx;
-};
-
-class CorpubProcess : public CordbCommonBase, public ICorPublishProcess
-{
-public:
- CorpubProcess(const ProcessDescriptor * pProcessDescriptor,
- bool fManaged,
- HANDLE hProcess,
- HANDLE hMutex,
- AppDomainEnumerationIPCBlock *pAD,
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI)
- IPCReaderInterface *pIPCReader,
-#endif // !FEATURE_DBGIPC_TRANSPORT_DI
- FPGetModuleFileNameEx * fpGetModuleFileNameEx);
- virtual ~CorpubProcess();
-
-#ifdef _DEBUG
- virtual const char * DbgGetName() { return "CorpubProcess"; }
-#endif
-
-
- //-----------------------------------------------------------
- // IUnknown
- //-----------------------------------------------------------
-
- ULONG STDMETHODCALLTYPE AddRef()
- {
- return (BaseAddRef());
- }
- ULONG STDMETHODCALLTYPE Release()
- {
- return (BaseRelease());
- }
- COM_METHOD QueryInterface(REFIID riid, void **ppInterface);
-
- //-----------------------------------------------------------
- // ICorPublishProcess
- //-----------------------------------------------------------
- COM_METHOD IsManaged(BOOL *pbManaged);
-
- /*
- * Enumerate the list of known application domains in the target process.
- */
- COM_METHOD EnumAppDomains(ICorPublishAppDomainEnum **ppEnum);
-
- /*
- * Returns the OS ID for the process in question.
- */
- COM_METHOD GetProcessID(unsigned *pid);
-
- /*
- * Get the display name for a process.
- */
- COM_METHOD GetDisplayName(ULONG32 cchName,
- ULONG32 *pcchName,
- _Out_writes_to_opt_(cchName, *pcchName) WCHAR szName[]);
-
- CorpubProcess *GetNextProcess () { return m_pNext;}
- void SetNext (CorpubProcess *pNext) { m_pNext = pNext;}
-
- // Helper to tell if this process has exited
- bool IsExited();
-
-public:
- ProcessDescriptor m_processDescriptor;
-
-private:
- bool m_fIsManaged;
- HANDLE m_hProcess;
- HANDLE m_hMutex;
- AppDomainEnumerationIPCBlock *m_AppDomainCB;
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI)
- IPCReaderInterface *m_pIPCReader; // controls the lifetime of the AppDomainEnumerationIPCBlock
-#endif // !FEATURE_DBGIPC_TRANSPORT_DI
- CorpubProcess *m_pNext; // pointer to the next process in the process list
- WCHAR *m_szProcessName;
-
-};
-
-class CorpubAppDomain : public CordbCommonBase, public ICorPublishAppDomain
-{
-public:
- CorpubAppDomain (_In_ LPWSTR szAppDomainName, ULONG Id);
- virtual ~CorpubAppDomain();
-
-#ifdef _DEBUG
- virtual const char * DbgGetName() { return "CorpubAppDomain"; }
-#endif
-
- //-----------------------------------------------------------
- // IUnknown
- //-----------------------------------------------------------
-
- ULONG STDMETHODCALLTYPE AddRef()
- {
- return (BaseAddRef());
- }
- ULONG STDMETHODCALLTYPE Release()
- {
- return (BaseRelease());
- }
- COM_METHOD QueryInterface (REFIID riid, void **ppInterface);
-
- //-----------------------------------------------------------
- // ICorPublishAppDomain
- //-----------------------------------------------------------
-
- /*
- * Get the name and ID for an application domain.
- */
- COM_METHOD GetID (ULONG32 *pId);
-
- /*
- * Get the name for an application domain.
- */
- COM_METHOD GetName (ULONG32 cchName,
- ULONG32 *pcchName,
- _Out_writes_to_opt_(cchName, *pcchName) WCHAR szName[]);
-
- CorpubAppDomain *GetNextAppDomain () { return m_pNext;}
- void SetNext (CorpubAppDomain *pNext) { m_pNext = pNext;}
-
-private:
- CorpubAppDomain *m_pNext;
- WCHAR *m_szAppDomainName;
- ULONG m_id;
-
-};
-
-class CorpubProcessEnum : public CordbCommonBase, public ICorPublishProcessEnum
-{
-public:
- CorpubProcessEnum(CorpubProcess *pFirst);
- virtual ~CorpubProcessEnum();
-
-#ifdef _DEBUG
- virtual const char * DbgGetName() { return "CorpubProcessEnum"; }
-#endif
-
-
- //-----------------------------------------------------------
- // IUnknown
- //-----------------------------------------------------------
-
- ULONG STDMETHODCALLTYPE AddRef()
- {
- return (BaseAddRef());
- }
- ULONG STDMETHODCALLTYPE Release()
- {
- return (BaseRelease());
- }
- COM_METHOD QueryInterface(REFIID riid, void **ppInterface);
-
- //-----------------------------------------------------------
- // ICorPublishProcessEnum
- //-----------------------------------------------------------
-
- COM_METHOD Skip(ULONG celt);
- COM_METHOD Reset();
- COM_METHOD Clone(ICorPublishEnum **ppEnum);
- COM_METHOD GetCount(ULONG *pcelt);
- COM_METHOD Next(ULONG celt,
- ICorPublishProcess *objects[],
- ULONG *pceltFetched);
-
-private:
- CorpubProcess *m_pFirst;
- CorpubProcess *m_pCurrent;
-
-};
-
-class CorpubAppDomainEnum : public CordbCommonBase, public ICorPublishAppDomainEnum
-{
-public:
- CorpubAppDomainEnum(CorpubAppDomain *pFirst);
- virtual ~CorpubAppDomainEnum();
-
-
-#ifdef _DEBUG
- virtual const char * DbgGetName() { return "CordbAppDomainEnum"; }
-#endif
-
-
- //-----------------------------------------------------------
- // IUnknown
- //-----------------------------------------------------------
-
- ULONG STDMETHODCALLTYPE AddRef()
- {
- return (BaseAddRef());
- }
- ULONG STDMETHODCALLTYPE Release()
- {
- return (BaseRelease());
- }
- COM_METHOD QueryInterface(REFIID riid, void **ppInterface);
-
- //-----------------------------------------------------------
- // ICorPublishAppDomainEnum
- //-----------------------------------------------------------
- COM_METHOD Skip(ULONG celt);
- COM_METHOD Reset();
- COM_METHOD Clone(ICorPublishEnum **ppEnum);
- COM_METHOD GetCount(ULONG *pcelt);
-
- COM_METHOD Next(ULONG celt,
- ICorPublishAppDomain *objects[],
- ULONG *pceltFetched);
-
-private:
- CorpubAppDomain *m_pFirst;
- CorpubAppDomain *m_pCurrent;
-
-};
-
-#endif // defined(FEATURE_DBG_PUBLISH)
-
class CordbHeapEnum : public CordbBase, public ICorDebugHeapEnum
{
public:
diff --git a/src/coreclr/debug/di/rsthread.cpp b/src/coreclr/debug/di/rsthread.cpp
index 8b9ec41240ea59..07e591d15fb116 100644
--- a/src/coreclr/debug/di/rsthread.cpp
+++ b/src/coreclr/debug/di/rsthread.cpp
@@ -3706,9 +3706,9 @@ HRESULT CordbUnmanagedThread::SetupFirstChanceHijackForSync()
// to avoid getting incomplete information and corrupt the thread context
DT_CONTEXT context;
#if defined(DT_CONTEXT_EXTENDED_REGISTERS)
- context.ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_EXTENDED_REGISTERS;
+ context.ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_FLOATING_POINT | DT_CONTEXT_EXTENDED_REGISTERS;
#else
- context.ContextFlags = DT_CONTEXT_FULL;
+ context.ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_FLOATING_POINT;
#endif
BOOL succ = DbiGetThreadContext(m_handle, &context);
_ASSERTE(succ);
@@ -3719,9 +3719,9 @@ HRESULT CordbUnmanagedThread::SetupFirstChanceHijackForSync()
LOG((LF_CORDB, LL_ERROR, "CUT::SFCHFS: DbiGetThreadContext error=0x%x\n", error));
}
#if defined(DT_CONTEXT_EXTENDED_REGISTERS)
- GetHijackCtx()->ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_EXTENDED_REGISTERS;
+ GetHijackCtx()->ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_FLOATING_POINT | DT_CONTEXT_EXTENDED_REGISTERS;
#else
- GetHijackCtx()->ContextFlags = DT_CONTEXT_FULL;
+ GetHijackCtx()->ContextFlags = DT_CONTEXT_FULL | DT_CONTEXT_FLOATING_POINT;
#endif
CORDbgCopyThreadContext(GetHijackCtx(), &context);
LOG((LF_CORDB, LL_INFO10000, "CUT::SFCHFS: thread=0x%x Hijacking for sync. Original context is:\n", this));
diff --git a/src/coreclr/debug/di/shimstackwalk.cpp b/src/coreclr/debug/di/shimstackwalk.cpp
index 64ea5d7ad7d918..d3385d2cc40ceb 100644
--- a/src/coreclr/debug/di/shimstackwalk.cpp
+++ b/src/coreclr/debug/di/shimstackwalk.cpp
@@ -1202,7 +1202,7 @@ BOOL ShimStackWalk::CheckInternalFrame(ICorDebugFrame * pNextStackFrame,
// Special handling for the case where a managed method contains a M2U internal frame.
// Normally only IL stubs contain M2U internal frames, but we may have inlined pinvoke calls in
// optimized code. In that case, we would have an InlinedCallFrame in a normal managed method on x86.
- // On WIN64, we would have a normal NDirectMethodFrame* in a normal managed method.
+ // On WIN64, we would have a normal PInvokeMethodFrame* in a normal managed method.
if (pStackWalkInfo->m_internalFrameType == STUBFRAME_M2U)
{
// create a temporary ICDStackWalk
diff --git a/src/coreclr/debug/di/stdafx.h b/src/coreclr/debug/di/stdafx.h
index 8ee806f88f2718..0f1ae48265b9de 100644
--- a/src/coreclr/debug/di/stdafx.h
+++ b/src/coreclr/debug/di/stdafx.h
@@ -29,7 +29,6 @@ using std::max;
#include "ex.h"
#include "sigparser.h"
-#include "corpub.h"
#include "rspriv.h"
// This is included to deal with GCC limitations around templates.
diff --git a/src/coreclr/debug/ee/controller.cpp b/src/coreclr/debug/ee/controller.cpp
index a7bed1a1001bfd..794f0a693bfeb8 100644
--- a/src/coreclr/debug/ee/controller.cpp
+++ b/src/coreclr/debug/ee/controller.cpp
@@ -67,9 +67,79 @@ bool DebuggerControllerPatch::IsSafeForStackTrace()
}
+#ifndef DACCESS_COMPILE
#ifndef FEATURE_EMULATE_SINGLESTEP
-// returns a pointer to the shared buffer. each call will AddRef() the object
-// before returning it so callers only need to Release() when they're finished with it.
+
+//
+// We have to have a whole separate function for this because you
+// can't use __try in a function that requires object unwinding...
+//
+
+LONG FilterAccessViolation2(LPEXCEPTION_POINTERS ep, PVOID pv)
+{
+ LIMITED_METHOD_CONTRACT;
+
+ return (ep->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
+ ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
+}
+
+// This helper is required because the AVInRuntimeImplOkayHolder can not
+// be directly placed inside the scope of a PAL_TRY
+void _CopyInstructionBlockHelper(BYTE* to, const BYTE* from)
+{
+ AVInRuntimeImplOkayHolder AVOkay;
+
+ // This function only copies the portion of the instruction that follows the
+ // breakpoint opcode, not the breakpoint itself
+ to += CORDbg_BREAK_INSTRUCTION_SIZE;
+ from += CORDbg_BREAK_INSTRUCTION_SIZE;
+
+ // If an AV occurs because we walked off a valid page then we need
+ // to be certain that all bytes on the previous page were copied.
+ // We are certain that we copied enough bytes to contain the instruction
+ // because it must have fit within the valid page.
+ for (int i = 0; i < MAX_INSTRUCTION_LENGTH - CORDbg_BREAK_INSTRUCTION_SIZE; i++)
+ {
+ *to++ = *from++;
+ }
+
+}
+
+// WARNING: this function skips copying the first CORDbg_BREAK_INSTRUCTION_SIZE bytes by design
+// See the comment at the callsite in DebuggerPatchSkip::DebuggerPatchSkip for more details on
+// this
+void DebuggerControllerPatch::CopyInstructionBlock(BYTE *to, const BYTE* from)
+{
+ // We wrap the memcpy in an exception handler to handle the
+ // extremely rare case where we're copying an instruction off the
+ // end of a method that is also at the end of a page, and the next
+ // page is unmapped.
+ struct Param
+ {
+ BYTE *to;
+ const BYTE* from;
+ } param;
+ param.to = to;
+ param.from = from;
+ PAL_TRY(Param *, pParam, ¶m)
+ {
+ _CopyInstructionBlockHelper(pParam->to, pParam->from);
+ }
+ PAL_EXCEPT_FILTER(FilterAccessViolation2)
+ {
+ // The whole point is that if we copy up the AV, then
+ // that's enough to execute, otherwise we would not have been
+ // able to execute the code anyway. So we just ignore the
+ // exception.
+ LOG((LF_CORDB, LL_INFO10000,
+ "DCP::CIP: AV copying instruction block ignored.\n"));
+ }
+ PAL_ENDTRY
+}
+
+
+// Creates a new shared patch bypass buffer
+// AddRef() before returning it so callers need to Release() when they're finished with it.
SharedPatchBypassBuffer* DebuggerControllerPatch::GetOrCreateSharedPatchBypassBuffer()
{
CONTRACTL
@@ -79,27 +149,110 @@ SharedPatchBypassBuffer* DebuggerControllerPatch::GetOrCreateSharedPatchBypassBu
}
CONTRACTL_END;
- if (m_pSharedPatchBypassBuffer == NULL)
+ if (m_pSharedPatchBypassBuffer != NULL)
{
- void *pSharedPatchBypassBufferRX = g_pDebugger->GetInteropSafeExecutableHeap()->Alloc(sizeof(SharedPatchBypassBuffer));
+ m_pSharedPatchBypassBuffer->AddRef();
+ return m_pSharedPatchBypassBuffer;
+ }
+
+ // NOTE: in order to correctly single-step RIP-relative writes on multiple threads we need to set up
+ // a shared buffer with the instruction and a buffer for the RIP-relative value so that all threads
+ // are working on the same copy. as the single-steps complete the modified data in the buffer is
+ // copied back to the real address to ensure proper execution of the program.
+
+ SharedPatchBypassBuffer *pSharedPatchBypassBufferRX = (SharedPatchBypassBuffer*)g_pDebugger->GetInteropSafeExecutableHeap()->Alloc(sizeof(SharedPatchBypassBuffer));
#if defined(HOST_OSX) && defined(HOST_ARM64)
- ExecutableWriterHolder sharedPatchBypassBufferWriterHolder((SharedPatchBypassBuffer*)pSharedPatchBypassBufferRX, sizeof(SharedPatchBypassBuffer));
- void *pSharedPatchBypassBufferRW = sharedPatchBypassBufferWriterHolder.GetRW();
+ ExecutableWriterHolder sharedPatchBypassBufferWriterHolder((SharedPatchBypassBuffer*)pSharedPatchBypassBufferRX, sizeof(SharedPatchBypassBuffer));
+ SharedPatchBypassBuffer *pSharedPatchBypassBufferRW = sharedPatchBypassBufferWriterHolder.GetRW();
#else // HOST_OSX && HOST_ARM64
- void *pSharedPatchBypassBufferRW = pSharedPatchBypassBufferRX;
+ SharedPatchBypassBuffer *pSharedPatchBypassBufferRW = pSharedPatchBypassBufferRX;
#endif // HOST_OSX && HOST_ARM64
- new (pSharedPatchBypassBufferRW) SharedPatchBypassBuffer();
- m_pSharedPatchBypassBuffer = (SharedPatchBypassBuffer*)pSharedPatchBypassBufferRX;
-
- _ASSERTE(m_pSharedPatchBypassBuffer);
- TRACE_ALLOC(m_pSharedPatchBypassBuffer);
- }
+ new (pSharedPatchBypassBufferRW) SharedPatchBypassBuffer();
+ m_pSharedPatchBypassBuffer = (SharedPatchBypassBuffer*)pSharedPatchBypassBufferRX;
+ _ASSERTE(m_pSharedPatchBypassBuffer);
+ TRACE_ALLOC(m_pSharedPatchBypassBuffer);
m_pSharedPatchBypassBuffer->AddRef();
+ BYTE* patchBypassRW = pSharedPatchBypassBufferRW->PatchBypass;
+ BYTE* patchBypassRX = m_pSharedPatchBypassBuffer->PatchBypass;
+
+ LOG((LF_CORDB, LL_INFO10000, "DCP::CSPBB: Patch skip for opcode 0x%.4x at address %p buffer allocated at 0x%.8x\n", this->opcode, this->address, m_pSharedPatchBypassBuffer));
+
+ // CopyInstructionBlock copies all the code bytes except the breakpoint byte(s).
+ _ASSERTE( this->IsBound() );
+ CopyInstructionBlock(patchBypassRW, (const BYTE *)this->address);
+
+ // Technically, we could create a patch skipper for an inactive patch, but we rely on the opcode being
+ // set here.
+ _ASSERTE( this->IsActivated() );
+ CORDbgSetInstruction((CORDB_ADDRESS_TYPE *)patchBypassRW, this->opcode);
+
+ LOG((LF_CORDB, LL_EVERYTHING, "DCP::CSPBB: SetInstruction was called\n"));
+
+ //
+ // Look at instruction to get some attributes
+ //
+ InstructionAttribute instrAttrib = { 0 };
+ NativeWalker::DecodeInstructionForPatchSkip(patchBypassRX, &instrAttrib);
+
+#if defined(TARGET_AMD64)
+ // The code below handles RIP-relative addressing on AMD64. The original implementation made the assumption that
+ // we are only using RIP-relative addressing to access read-only data (see VSW 246145 for more information). This
+ // has since been expanded to handle RIP-relative writes as well.
+ if (instrAttrib.m_dwOffsetToDisp != 0)
+ {
+ _ASSERTE(pSharedPatchBypassBufferRW != NULL);
+ _ASSERTE(instrAttrib.m_cbInstr != 0);
+
+ //
+ // Populate the RIP-relative buffer with the current value if needed
+ //
+
+ BYTE* bufferBypassRW = pSharedPatchBypassBufferRW->BypassBuffer;
+
+ // Overwrite the *signed* displacement.
+ int dwOldDisp = *(int*)(&patchBypassRX[instrAttrib.m_dwOffsetToDisp]);
+ int dwNewDisp = offsetof(SharedPatchBypassBuffer, BypassBuffer) -
+ (offsetof(SharedPatchBypassBuffer, PatchBypass) + instrAttrib.m_cbInstr);
+ *(int*)(&patchBypassRW[instrAttrib.m_dwOffsetToDisp]) = dwNewDisp;
+
+ // This could be an LEA, which we'll just have to change into a MOV and copy the original address.
+ if (((patchBypassRX[0] == 0x4C) || (patchBypassRX[0] == 0x48)) && (patchBypassRX[1] == 0x8d))
+ {
+ patchBypassRW[1] = 0x8b; // MOV reg, mem
+ _ASSERTE((int)sizeof(void*) <= SharedPatchBypassBuffer::cbBufferBypass);
+ *(void**)bufferBypassRW = (void*)(this->address + instrAttrib.m_cbInstr + dwOldDisp);
+ }
+ else
+ {
+ _ASSERTE(instrAttrib.m_cOperandSize <= SharedPatchBypassBuffer::cbBufferBypass);
+ // Copy the data into our buffer.
+ memcpy(bufferBypassRW, this->address + instrAttrib.m_cbInstr + dwOldDisp, instrAttrib.m_cOperandSize);
+
+ if (instrAttrib.m_fIsWrite)
+ {
+ // save the actual destination address and size so when we TriggerSingleStep() we can update the value
+ pSharedPatchBypassBufferRW->RipTargetFixup = (UINT_PTR)(this->address + instrAttrib.m_cbInstr + dwOldDisp);
+ pSharedPatchBypassBufferRW->RipTargetFixupSize = instrAttrib.m_cOperandSize;
+ }
+ }
+ }
+
+ #endif // TARGET_AMD64
+
+ m_pSharedPatchBypassBuffer->SetInstructionAttrib(instrAttrib);
+
+ // Since we just created a new buffer of code, but the CPU caches code and may
+ // not be aware of our changes. This should force the CPU to dump any cached
+ // instructions it has in this region and load the new ones from memory
+ FlushInstructionCache(GetCurrentProcess(), patchBypassRW + CORDbg_BREAK_INSTRUCTION_SIZE,
+ MAX_INSTRUCTION_LENGTH - CORDbg_BREAK_INSTRUCTION_SIZE);
+
return m_pSharedPatchBypassBuffer;
}
#endif // !FEATURE_EMULATE_SINGLESTEP
+#endif // !DACCESS_COMPILE
// @todo - remove all this splicing trash
// This Sort/Splice stuff just reorders the patches within a particular chain such
@@ -4509,53 +4662,9 @@ DebuggerPatchSkip::DebuggerPatchSkip(Thread *thread,
// the single-step emulation itself.
#ifndef FEATURE_EMULATE_SINGLESTEP
- // NOTE: in order to correctly single-step RIP-relative writes on multiple threads we need to set up
- // a shared buffer with the instruction and a buffer for the RIP-relative value so that all threads
- // are working on the same copy. as the single-steps complete the modified data in the buffer is
- // copied back to the real address to ensure proper execution of the program.
-
- //
- // Create the shared instruction block. this will also create the shared RIP-relative buffer
- //
-
+ _ASSERTE(DebuggerController::HasLock());
m_pSharedPatchBypassBuffer = patch->GetOrCreateSharedPatchBypassBuffer();
-#if defined(HOST_OSX) && defined(HOST_ARM64)
- ExecutableWriterHolder sharedPatchBypassBufferWriterHolder((SharedPatchBypassBuffer*)m_pSharedPatchBypassBuffer, sizeof(SharedPatchBypassBuffer));
- SharedPatchBypassBuffer *pSharedPatchBypassBufferRW = sharedPatchBypassBufferWriterHolder.GetRW();
-#else // HOST_OSX && HOST_ARM64
- SharedPatchBypassBuffer *pSharedPatchBypassBufferRW = m_pSharedPatchBypassBuffer;
-#endif // HOST_OSX && HOST_ARM64
-
- BYTE* patchBypassRX = m_pSharedPatchBypassBuffer->PatchBypass;
- BYTE* patchBypassRW = pSharedPatchBypassBufferRW->PatchBypass;
- LOG((LF_CORDB, LL_INFO10000, "DPS::DPS: Patch skip for opcode 0x%.4x at address %p buffer allocated at 0x%.8x\n", patch->opcode, patch->address, m_pSharedPatchBypassBuffer));
-
- // Copy the instruction block over to the patch skip
- // WARNING: there used to be an issue here because CopyInstructionBlock copied the breakpoint from the
- // jitted code stream into the patch buffer. Further below CORDbgSetInstruction would correct the
- // first instruction. This buffer is shared by all threads so if another thread executed the buffer
- // between this thread's execution of CopyInstructionBlock and CORDbgSetInstruction the wrong
- // code would be executed. The bug has been fixed by changing CopyInstructionBlock to only copy
- // the code bytes after the breakpoint.
- // You might be tempted to stop copying the code at all, however that wouldn't work well with rejit.
- // If we skip a breakpoint that is sitting at the beginning of a method, then the profiler rejits that
- // method causing a jump-stamp to be placed, then we skip the breakpoint again, we need to make sure
- // the 2nd skip executes the new jump-stamp code and not the original method prologue code. Copying
- // the code every time ensures that we have the most up-to-date version of the code in the buffer.
- _ASSERTE( patch->IsBound() );
- CopyInstructionBlock(patchBypassRW, (const BYTE *)patch->address);
-
- // Technically, we could create a patch skipper for an inactive patch, but we rely on the opcode being
- // set here.
- _ASSERTE( patch->IsActivated() );
- CORDbgSetInstruction((CORDB_ADDRESS_TYPE *)patchBypassRW, patch->opcode);
-
- LOG((LF_CORDB, LL_EVERYTHING, "SetInstruction was called\n"));
- //
- // Look at instruction to get some attributes
- //
-
- NativeWalker::DecodeInstructionForPatchSkip(patchBypassRX, &(m_instrAttrib));
+ m_instrAttrib = m_pSharedPatchBypassBuffer->GetInstructionAttrib();
#ifdef OUT_OF_PROCESS_SETTHREADCONTEXT
if (g_pDebugInterface->IsOutOfProcessSetContextEnabled() && m_instrAttrib.m_fIsCall)
@@ -4564,51 +4673,6 @@ DebuggerPatchSkip::DebuggerPatchSkip(Thread *thread,
}
#endif
-#if defined(TARGET_AMD64)
-
- // The code below handles RIP-relative addressing on AMD64. The original implementation made the assumption that
- // we are only using RIP-relative addressing to access read-only data (see VSW 246145 for more information). This
- // has since been expanded to handle RIP-relative writes as well.
- if (m_instrAttrib.m_dwOffsetToDisp != 0 && !IsInPlaceSingleStep())
- {
- _ASSERTE(m_instrAttrib.m_cbInstr != 0);
-
- //
- // Populate the RIP-relative buffer with the current value if needed
- //
-
- BYTE* bufferBypassRW = pSharedPatchBypassBufferRW->BypassBuffer;
-
- // Overwrite the *signed* displacement.
- int dwOldDisp = *(int*)(&patchBypassRX[m_instrAttrib.m_dwOffsetToDisp]);
- int dwNewDisp = offsetof(SharedPatchBypassBuffer, BypassBuffer) -
- (offsetof(SharedPatchBypassBuffer, PatchBypass) + m_instrAttrib.m_cbInstr);
- *(int*)(&patchBypassRW[m_instrAttrib.m_dwOffsetToDisp]) = dwNewDisp;
-
- // This could be an LEA, which we'll just have to change into a MOV and copy the original address.
- if (((patchBypassRX[0] == 0x4C) || (patchBypassRX[0] == 0x48)) && (patchBypassRX[1] == 0x8d))
- {
- patchBypassRW[1] = 0x8b; // MOV reg, mem
- _ASSERTE((int)sizeof(void*) <= SharedPatchBypassBuffer::cbBufferBypass);
- *(void**)bufferBypassRW = (void*)(patch->address + m_instrAttrib.m_cbInstr + dwOldDisp);
- }
- else
- {
- _ASSERTE(m_instrAttrib.m_cOperandSize <= SharedPatchBypassBuffer::cbBufferBypass);
- // Copy the data into our buffer.
- memcpy(bufferBypassRW, patch->address + m_instrAttrib.m_cbInstr + dwOldDisp, m_instrAttrib.m_cOperandSize);
-
- if (m_instrAttrib.m_fIsWrite)
- {
- // save the actual destination address and size so when we TriggerSingleStep() we can update the value
- pSharedPatchBypassBufferRW->RipTargetFixup = (UINT_PTR)(patch->address + m_instrAttrib.m_cbInstr + dwOldDisp);
- pSharedPatchBypassBufferRW->RipTargetFixupSize = m_instrAttrib.m_cOperandSize;
- }
- }
- }
-
-#endif // TARGET_AMD64
-
#endif // !FEATURE_EMULATE_SINGLESTEP
// Signals our thread that the debugger will be manipulating the context
@@ -4672,7 +4736,9 @@ DebuggerPatchSkip::DebuggerPatchSkip(Thread *thread,
#else // FEATURE_EMULATE_SINGLESTEP
#ifdef TARGET_ARM64
- patchBypassRX = NativeWalker::SetupOrSimulateInstructionForPatchSkip(context, m_pSharedPatchBypassBuffer, (const BYTE *)patch->address, patch->opcode);
+ BYTE* patchBypassRX = NativeWalker::SetupOrSimulateInstructionForPatchSkip(context, m_pSharedPatchBypassBuffer, (const BYTE *)patch->address, patch->opcode);
+#else
+ BYTE* patchBypassRX = m_pSharedPatchBypassBuffer->PatchBypass;
#endif //TARGET_ARM64
if (!IsInPlaceSingleStep())
@@ -4742,80 +4808,6 @@ void DebuggerPatchSkip::DebuggerDetachClean()
#endif // !FEATURE_EMULATE_SINGLESTEP
}
-
-//
-// We have to have a whole separate function for this because you
-// can't use __try in a function that requires object unwinding...
-//
-
-LONG FilterAccessViolation2(LPEXCEPTION_POINTERS ep, PVOID pv)
-{
- LIMITED_METHOD_CONTRACT;
-
- return (ep->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
- ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
-}
-
-// This helper is required because the AVInRuntimeImplOkayHolder can not
-// be directly placed inside the scope of a PAL_TRY
-void _CopyInstructionBlockHelper(BYTE* to, const BYTE* from)
-{
- AVInRuntimeImplOkayHolder AVOkay;
-
- // This function only copies the portion of the instruction that follows the
- // breakpoint opcode, not the breakpoint itself
- to += CORDbg_BREAK_INSTRUCTION_SIZE;
- from += CORDbg_BREAK_INSTRUCTION_SIZE;
-
- // If an AV occurs because we walked off a valid page then we need
- // to be certain that all bytes on the previous page were copied.
- // We are certain that we copied enough bytes to contain the instruction
- // because it must have fit within the valid page.
- for (int i = 0; i < MAX_INSTRUCTION_LENGTH - CORDbg_BREAK_INSTRUCTION_SIZE; i++)
- {
- *to++ = *from++;
- }
-
-}
-
-// WARNING: this function skips copying the first CORDbg_BREAK_INSTRUCTION_SIZE bytes by design
-// See the comment at the callsite in DebuggerPatchSkip::DebuggerPatchSkip for more details on
-// this
-void DebuggerPatchSkip::CopyInstructionBlock(BYTE *to, const BYTE* from)
-{
- // We wrap the memcpy in an exception handler to handle the
- // extremely rare case where we're copying an instruction off the
- // end of a method that is also at the end of a page, and the next
- // page is unmapped.
- struct Param
- {
- BYTE *to;
- const BYTE* from;
- } param;
- param.to = to;
- param.from = from;
- PAL_TRY(Param *, pParam, ¶m)
- {
- _CopyInstructionBlockHelper(pParam->to, pParam->from);
- }
- PAL_EXCEPT_FILTER(FilterAccessViolation2)
- {
- // The whole point is that if we copy up the AV, then
- // that's enough to execute, otherwise we would not have been
- // able to execute the code anyway. So we just ignore the
- // exception.
- LOG((LF_CORDB, LL_INFO10000,
- "DPS::DPS: AV copying instruction block ignored.\n"));
- }
- PAL_ENDTRY
-
- // We just created a new buffer of code, but the CPU caches code and may
- // not be aware of our changes. This should force the CPU to dump any cached
- // instructions it has in this region and load the new ones from memory
- FlushInstructionCache(GetCurrentProcess(), to + CORDbg_BREAK_INSTRUCTION_SIZE,
- MAX_INSTRUCTION_LENGTH - CORDbg_BREAK_INSTRUCTION_SIZE);
-}
-
TP_RESULT DebuggerPatchSkip::TriggerPatch(DebuggerControllerPatch *patch,
Thread *thread,
TRIGGER_WHY tyWhy)
@@ -5929,7 +5921,7 @@ bool DebuggerStepper::TrapStep(ControllerStackInfo *info, bool in)
#endif
// Note: we used to pass in the IP from the active frame to GetJitInfo, but there seems to be no value in that, and
- // it was causing problems creating a stepper while sitting in ndirect stubs after we'd returned from the unmanaged
+ // it was causing problems creating a stepper while sitting in PInvoke stubs after we'd returned from the unmanaged
// function that had been called.
DebuggerJitInfo *ji = info->m_activeFrame.GetJitInfoFromFrame();
if( ji != NULL )
@@ -6545,7 +6537,7 @@ void DebuggerStepper::TrapStepOut(ControllerStackInfo *info, bool fForceTraditio
_ASSERTE(dji != NULL);
// Note: we used to pass in the IP from the active frame to GetJitInfo, but there seems to be no value
- // in that, and it was causing problems creating a stepper while sitting in ndirect stubs after we'd
+ // in that, and it was causing problems creating a stepper while sitting in PInvoke stubs after we'd
// returned from the unmanaged function that had been called.
ULONG reloffset = info->m_activeFrame.relOffset;
@@ -6824,7 +6816,7 @@ bool DebuggerStepper::SetRangesFromIL(DebuggerJitInfo *dji, COR_DEBUG_STEP_RANGE
CONTRACTL_END;
// Note: we used to pass in the IP from the active frame to GetJitInfo, but there seems to be no value in that, and
- // it was causing problems creating a stepper while sitting in ndirect stubs after we'd returned from the unmanaged
+ // it was causing problems creating a stepper while sitting in PInvoke stubs after we'd returned from the unmanaged
// function that had been called.
MethodDesc *fd = dji->m_nativeCodeVersion.GetMethodDesc();
diff --git a/src/coreclr/debug/ee/controller.h b/src/coreclr/debug/ee/controller.h
index b02cd2802d91ad..32138edc36aba7 100644
--- a/src/coreclr/debug/ee/controller.h
+++ b/src/coreclr/debug/ee/controller.h
@@ -312,7 +312,11 @@ class SharedPatchBypassBuffer
UINT_PTR RipTargetFixup;
#endif
+ const InstructionAttribute& GetInstructionAttrib() { return m_instrAttrib; }
+ void SetInstructionAttrib(const InstructionAttribute& instrAttrib) { m_instrAttrib = instrAttrib; }
+
private:
+ InstructionAttribute m_instrAttrib; // info about the instruction being skipped over
const static DWORD SentinelValue = 0xffffffff;
LONG m_refCount;
};
@@ -550,10 +554,13 @@ struct DebuggerControllerPatch
// Is this patch at a position at which it's safe to take a stack?
bool IsSafeForStackTrace();
+#ifndef DACCESS_COMPILE
#ifndef FEATURE_EMULATE_SINGLESTEP
// gets a pointer to the shared buffer
SharedPatchBypassBuffer* GetOrCreateSharedPatchBypassBuffer();
+ void CopyInstructionBlock(BYTE *to, const BYTE* from);
+
// entry point for general initialization when the controller is being created
void Initialize()
{
@@ -567,6 +574,7 @@ struct DebuggerControllerPatch
m_pSharedPatchBypassBuffer->Release();
}
#endif // !FEATURE_EMULATE_SINGLESTEP
+#endif // !DACCESS_COMPILE
void LogInstance()
{
@@ -1515,8 +1523,6 @@ class DebuggerPatchSkip : public DebuggerController
virtual DEBUGGER_CONTROLLER_TYPE GetDCType(void)
{ return DEBUGGER_CONTROLLER_PATCH_SKIP; }
- void CopyInstructionBlock(BYTE *to, const BYTE* from);
-
void DecodeInstruction(CORDB_ADDRESS_TYPE *code);
void DebuggerDetachClean();
diff --git a/src/coreclr/debug/ee/dactable.cpp b/src/coreclr/debug/ee/dactable.cpp
index 80d1995acf8928..9c65b163cf2799 100644
--- a/src/coreclr/debug/ee/dactable.cpp
+++ b/src/coreclr/debug/ee/dactable.cpp
@@ -18,15 +18,11 @@
#include "../../vm/common.h"
#include "../../vm/gcenv.h"
#include "../../vm/ecall.h"
+#include "../../vm/cdacplatformmetadata.hpp"
#ifdef DEBUGGING_SUPPORTED
-extern PTR_ECHash gFCallMethods[FCALL_HASH_SIZE];
-extern TADDR gLowestFCall;
-extern TADDR gHighestFCall;
extern PCODE g_FCDynamicallyAssignedImplementations[ECall::NUM_DYNAMICALLY_ASSIGNED_FCALL_IMPLEMENTATIONS];
-extern DWORD gThreadTLSIndex;
-extern DWORD gAppDomainTLSIndex;
extern "C" void STDCALL ThePreStubPatchLabel(void);
#ifdef FEATURE_COMWRAPPERS
diff --git a/src/coreclr/debug/ee/debugger.cpp b/src/coreclr/debug/ee/debugger.cpp
index 914b4abf61957a..9bc5cda485d176 100644
--- a/src/coreclr/debug/ee/debugger.cpp
+++ b/src/coreclr/debug/ee/debugger.cpp
@@ -926,7 +926,6 @@ Debugger::Debugger()
m_jitAttachInProgress(FALSE),
m_launchingDebugger(FALSE),
m_LoggingEnabled(TRUE),
- m_pAppDomainCB(NULL),
m_dClassLoadCallbackCount(0),
m_pModules(NULL),
m_RSRequestedSync(FALSE),
@@ -1896,22 +1895,6 @@ HRESULT Debugger::Startup(void)
InitializeHijackFunctionAddress();
- // Also initialize the AppDomainEnumerationIPCBlock
- #if !defined(FEATURE_IPCMAN) || defined(FEATURE_DBGIPC_TRANSPORT_VM)
- m_pAppDomainCB = new (nothrow) AppDomainEnumerationIPCBlock();
- #else
- m_pAppDomainCB = g_pIPCManagerInterface->GetAppDomainBlock();
- #endif
-
- if (m_pAppDomainCB == NULL)
- {
- LOG((LF_CORDB, LL_INFO100, "D::S: Failed to get AppDomain IPC block from IPCManager.\n"));
- ThrowHR(E_FAIL);
- }
-
- hr = InitAppDomainIPC();
- _ASSERTE(SUCCEEDED(hr)); // throws on error.
-
// Allows the debugger (and profiler) diagnostics to be disabled so resources like
// the named pipes and semaphores are not created.
if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_EnableDiagnostics) == 0)
@@ -1939,7 +1922,7 @@ HRESULT Debugger::Startup(void)
#if defined(FEATURE_DBGIPC_TRANSPORT_VM)
// Create transport session and initialize it.
g_pDbgTransport = new DbgTransportSession();
- hr = g_pDbgTransport->Init(m_pRCThread->GetDCB(), m_pAppDomainCB);
+ hr = g_pDbgTransport->Init(m_pRCThread->GetDCB());
if (FAILED(hr))
{
ShutdownTransport();
@@ -2286,10 +2269,10 @@ void DebuggerLazyInit::Init()
DebuggerLazyInit::~DebuggerLazyInit()
{
{
- USHORT cBlobs = m_pMemBlobs.Count();
+ INT32 cBlobs = m_pMemBlobs.Count();
void **rgpBlobs = m_pMemBlobs.Table();
- for (int i = 0; i < cBlobs; i++)
+ for (INT32 i = 0; i < cBlobs; i++)
{
g_pDebugger->ReleaseRemoteBuffer(rgpBlobs[i], false);
}
@@ -2406,9 +2389,6 @@ void Debugger::StopDebugger(void)
m_pRCThread->AsyncStop();
}
- // Also clean up the AppDomain stuff since this is cross-process.
- TerminateAppDomainIPC ();
-
//
// Tell the VM to clear out all references to the debugger before we start cleaning up,
// so that nothing will reference (accidentally) through the partially cleaned up debugger.
@@ -2508,7 +2488,10 @@ void Debugger::JITComplete(NativeCodeVersion nativeCodeVersion, TADDR newAddress
// Can be called on managed thread only
// This API Implements DebugInterface
+#ifndef DEBUG // We need to do this in debug builds so that the ValidateILOffsets method can be called
+ // TODO: We may wish to remove this in the future.
if (CORDebuggerAttached())
+#endif
{
// Populate the debugger's cache of DJIs. Normally we can do this lazily,
// the only reason we do it here is b/c the MethodDesc is not yet officially marked as "jitted",
@@ -2876,10 +2859,11 @@ HRESULT Debugger::GetILToNativeMapping(PCODE pNativeCodeStartAddress, ULONG32 cM
{
DebugInfoRequest diq;
diq.InitFromStartingAddr(fd, pNativeCodeStartAddress);
+ // TODO This is currently returning the instrumented boundaries, but the path for non-dynamic methods returns uninstrumented ones.
if (cMap == 0)
{
- if (DebugInfoManager::GetBoundariesAndVars(diq, nullptr, nullptr, pcMap, nullptr, nullptr, nullptr))
+ if (DebugInfoManager::GetBoundariesAndVars(diq, nullptr, nullptr, BoundsType::Instrumented, pcMap, nullptr, nullptr, nullptr))
{
return S_OK;
}
@@ -2888,7 +2872,7 @@ HRESULT Debugger::GetILToNativeMapping(PCODE pNativeCodeStartAddress, ULONG32 cM
}
ICorDebugInfo::OffsetMapping* pMap = nullptr;
- if (DebugInfoManager::GetBoundariesAndVars(diq, InteropSafeNoThrowNew, nullptr, pcMap, &pMap, nullptr, nullptr))
+ if (DebugInfoManager::GetBoundariesAndVars(diq, InteropSafeNoThrowNew, nullptr, BoundsType::Instrumented, pcMap, &pMap, nullptr, nullptr))
{
for (ULONG32 i = 0; i < cMap; ++i)
{
@@ -2992,7 +2976,7 @@ HRESULT Debugger::GetILToNativeMapping(PCODE pNativeCodeStartAddress, ULONG32 cM
// events for the same MethodDesc (each time it's EnC'd), with each event
// corresponding to the most recent EnC version at the time.
//
-
+#ifdef DEBUG
HRESULT Debugger::GetILToNativeMappingIntoArrays(
MethodDesc * pMethodDesc,
PCODE pNativeCodeStartAddress,
@@ -3063,8 +3047,7 @@ HRESULT Debugger::GetILToNativeMappingIntoArrays(
return S_OK;
}
-
-
+#endif // DEBUG
#endif // #ifndef DACCESS_COMPILE
@@ -9177,7 +9160,7 @@ BOOL Debugger::SuspendComplete(bool isEESuspendedForGC)
//---------------------------------------------------------------------------------------
//
-// Debugger::SendCreateAppDomainEvent - notify the RS of an AppDomain
+// Debugger::AppDomainCreated - notify the RS of an AppDomain
//
// Arguments:
// pRuntimeAppdomain - pointer to the AppDomain
@@ -9187,18 +9170,13 @@ BOOL Debugger::SuspendComplete(bool isEESuspendedForGC)
//
// Notes:
// This is used to notify the debugger of either a newly created
-// AppDomain (when fAttaching is FALSE) or of existing AppDomains
-// at attach time (fAttaching is TRUE). In both cases, this should
+// AppDomain. This should
// be called before any LoadModule/LoadAssembly events are sent for
// this domain. Otherwise the RS will get an event for an AppDomain
// it doesn't recognize and ASSERT.
//
-// For the non-attach case this means there is no need to enumerate
-// the assemblies/modules in an AppDomain after sending this event
-// because we know there won't be any.
-//
-void Debugger::SendCreateAppDomainEvent(AppDomain * pRuntimeAppDomain)
+void Debugger::AppDomainCreated(AppDomain * pRuntimeAppDomain)
{
CONTRACTL
{
@@ -9222,8 +9200,6 @@ void Debugger::SendCreateAppDomainEvent(AppDomain * pRuntimeAppDomain)
Thread *pThread = g_pEEInterface->GetThread();
SENDIPCEVENT_BEGIN(this, pThread);
-
-
// We may have detached while waiting in LockForEventSending,
// in which case we can't send the event.
if (CORDebuggerAttached())
@@ -9247,62 +9223,6 @@ void Debugger::SendCreateAppDomainEvent(AppDomain * pRuntimeAppDomain)
}
-
-//
-// LoadAssembly is called when a new Assembly gets loaded.
-//
-void Debugger::LoadAssembly(DomainAssembly * pDomainAssembly)
-{
- CONTRACTL
- {
- MAY_DO_HELPER_THREAD_DUTY_THROWS_CONTRACT;
- MAY_DO_HELPER_THREAD_DUTY_GC_TRIGGERS_CONTRACT;
- }
- CONTRACTL_END;
-
- if (CORDBUnrecoverableError(this))
- return;
-
- LOG((LF_CORDB, LL_INFO100, "D::LA: Load Assembly Asy:0x%p AD:0x%p which:%s\n",
- pDomainAssembly, AppDomain::GetCurrentDomain(), pDomainAssembly->GetAssembly()->GetDebugName() ));
-
- if (!CORDebuggerAttached())
- {
- return;
- }
-
- Thread *pThread = g_pEEInterface->GetThread();
- SENDIPCEVENT_BEGIN(this, pThread)
-
-
- if (CORDebuggerAttached())
- {
- // Send a load assembly event to the Right Side.
- DebuggerIPCEvent* ipce = m_pRCThread->GetIPCEventSendBuffer();
- InitIPCEvent(ipce,
- DB_IPCE_LOAD_ASSEMBLY,
- pThread);
-
- ipce->AssemblyData.vmDomainAssembly.SetRawPtr(pDomainAssembly);
-
- m_pRCThread->SendIPCEvent();
- }
- else
- {
- LOG((LF_CORDB,LL_INFO1000, "D::LA: Skipping SendIPCEvent because RS detached."));
- }
-
- // Stop all Runtime threads
- if (CORDebuggerAttached())
- {
- TrapAllRuntimeThreads();
- }
-
- SENDIPCEVENT_END;
-}
-
-
-
//
// UnloadAssembly is called when a Runtime thread unloads an assembly.
//
@@ -9787,43 +9707,31 @@ BOOL Debugger::SendSystemClassLoadUnloadEvent(mdTypeDef classMetadataToken,
Assembly *pAssembly = classModule->GetAssembly();
- if (!m_pAppDomainCB->Lock())
- return (FALSE);
+ AppDomain *pAppDomain = GetAppDomain();
+ _ASSERTE(pAppDomain != NULL);
- AppDomainInfo *pADInfo = m_pAppDomainCB->FindFirst();
-
- while (pADInfo != NULL)
+ // Only notify for app domains where the module has been fully loaded already
+ // We used to make a different check here domain->ContainsAssembly() but that
+ // triggers too early in the loading process. FindDomainAssembly will not become
+ // non-NULL until the module is fully loaded into the domain which is what we
+ // want.
+ if (classModule->GetDomainAssembly() != NULL )
{
- AppDomain *pAppDomain = pADInfo->m_pAppDomain;
- _ASSERTE(pAppDomain != NULL);
+ // Find the Left Side module that this class belongs in.
+ DebuggerModule* pModule = LookupOrCreateModule(classModule);
+ _ASSERTE(pModule != NULL);
- // Only notify for app domains where the module has been fully loaded already
- // We used to make a different check here domain->ContainsAssembly() but that
- // triggers too early in the loading process. FindDomainAssembly will not become
- // non-NULL until the module is fully loaded into the domain which is what we
- // want.
- if (classModule->GetDomainAssembly() != NULL )
+ // Only send a class load event if they're enabled for this module.
+ if (pModule && pModule->ClassLoadCallbacksEnabled())
{
- // Find the Left Side module that this class belongs in.
- DebuggerModule* pModule = LookupOrCreateModule(classModule);
- _ASSERTE(pModule != NULL);
-
- // Only send a class load event if they're enabled for this module.
- if (pModule && pModule->ClassLoadCallbacksEnabled())
- {
- SendClassLoadUnloadEvent(classMetadataToken,
- pModule,
- pAssembly,
- fIsLoadEvent);
- fRetVal = TRUE;
- }
+ SendClassLoadUnloadEvent(classMetadataToken,
+ pModule,
+ pAssembly,
+ fIsLoadEvent);
+ fRetVal = TRUE;
}
-
- pADInfo = m_pAppDomainCB->FindNext(pADInfo);
}
- m_pAppDomainCB->Unlock();
-
return fRetVal;
}
@@ -12151,10 +12059,10 @@ HRESULT Debugger::ReleaseRemoteBuffer(void *pBuffer, bool removeFromBlobList)
// Remove the buffer from the blob list if necessary.
if (removeFromBlobList)
{
- USHORT cBlobs = GetMemBlobs()->Count();
+ INT32 cBlobs = GetMemBlobs()->Count();
void **rgpBlobs = GetMemBlobs()->Table();
- USHORT i;
+ INT32 i;
for (i = 0; i < cBlobs; i++)
{
if (rgpBlobs[i] == pBuffer)
@@ -14540,399 +14448,6 @@ void Debugger::SendCustomDebuggerNotification(Thread * pThread,
SENDIPCEVENT_END;
}
-
-//-----------------------------------------------------------------------------
-//
-// Add the AppDomain to the list stored in the IPC block. It adds the id and
-// the name.
-//
-// Arguments:
-// pAppDomain - The runtime app domain object to add.
-//
-// Return Value:
-// S_OK on success, else detailed error code.
-//
-HRESULT Debugger::AddAppDomainToIPC(AppDomain *pAppDomain)
-{
- CONTRACTL
- {
- MAY_DO_HELPER_THREAD_DUTY_THROWS_CONTRACT;
- GC_TRIGGERS;
- MODE_ANY;
- }
- CONTRACTL_END;
-
- HRESULT hr = S_OK;
- LPCWSTR szName = NULL;
-
- LOG((LF_CORDB, LL_INFO100, "D::AADTIPC: Executing AADTIPC for AppDomain 0x%08x.\n",
- pAppDomain));
-
- STRESS_LOG1(LF_CORDB, LL_INFO10000, "D::AADTIPC: AddAppDomainToIPC:%#08x\n",
- pAppDomain);
-
-
-
- _ASSERTE(m_pAppDomainCB->m_iTotalSlots > 0);
- _ASSERTE(m_pAppDomainCB->m_rgListOfAppDomains != NULL);
-
- {
- //
- // We need to synchronize this routine with the attach logic. The "normal"
- // attach case uses the HelperThread and TrapAllRuntimeThreads to synchronize
- // the runtime before sending any of the events (including AppDomainCreates)
- // to the right-side. Thus, we can synchronize with this case by forcing us
- // to go co-operative. If we were already co-op, then the helper thread will
- // wait to start the attach until all co-op threads are paused. If we were
- // pre-emptive, then going co-op will suspend us until the HelperThread finishes.
- //
- // The second case is under the IPC event for ATTACHING, which is where there are
- // zero app domains, so it is considered an 'early attach' case. To synchronize
- // with this we have to grab and hold the AppDomainDB lock.
- //
-
- GCX_COOP();
-
- // Lock the list
- if (!m_pAppDomainCB->Lock())
- {
- return E_FAIL;
- }
-
- // Get a free entry from the list
- AppDomainInfo *pAppDomainInfo = m_pAppDomainCB->GetFreeEntry();
-
- // Function returns NULL if the list is full and a realloc failed.
- if (!pAppDomainInfo)
- {
- hr = E_OUTOFMEMORY;
- goto LErrExit;
- }
-
- // Now set the AppDomainName.
-
- /*
- * TODO :
- *
- * Make sure that returning NULL here does not result in a catastrophic
- * failure.
- *
- * GetFriendlyNameNoThrow may call SetFriendlyName, which may call
- * UpdateAppDomainEntryInIPC. There is no recursive death, however, because
- * the AppDomainInfo object does not contain a pointer to the app domain
- * yet.
- */
- szName = pAppDomain->GetFriendlyNameForDebugger();
- pAppDomainInfo->SetName(szName);
-
- // Save on to the appdomain pointer
- pAppDomainInfo->m_pAppDomain = pAppDomain;
-
- // bump the used slot count
- m_pAppDomainCB->m_iNumOfUsedSlots++;
-
-LErrExit:
- // UnLock the list
- m_pAppDomainCB->Unlock();
-
- // Send event to debugger if one is attached.
- if (CORDebuggerAttached())
- {
- SendCreateAppDomainEvent(pAppDomain);
- }
- }
-
- return hr;
-}
-
-
-/******************************************************************************
- * Remove the AppDomain from the list stored in the IPC block and send an ExitAppDomain
- * event to the debugger if attached.
- ******************************************************************************/
-HRESULT Debugger::RemoveAppDomainFromIPC (AppDomain *pAppDomain)
-{
- CONTRACTL
- {
- MAY_DO_HELPER_THREAD_DUTY_THROWS_CONTRACT;
- MAY_DO_HELPER_THREAD_DUTY_GC_TRIGGERS_CONTRACT;
- }
- CONTRACTL_END;
-
- HRESULT hr = E_FAIL;
-
- LOG((LF_CORDB, LL_INFO100, "D::RADFIPC: Executing RADFIPC for AppDomain 0x%08x.\n",
- pAppDomain));
-
- // if none of the slots are occupied, then simply return.
- if (m_pAppDomainCB->m_iNumOfUsedSlots == 0)
- return hr;
-
- // Lock the list
- if (!m_pAppDomainCB->Lock())
- return (E_FAIL);
-
-
- // Look for the entry
- AppDomainInfo *pADInfo = m_pAppDomainCB->FindEntry(pAppDomain);
-
- // Shouldn't be trying to remove an appdomain that was never added
- if (!pADInfo)
- {
- // We'd like to assert this, but there is a small window where we may have
- // called AppDomain::Init (and so it's fair game to call Stop, and hence come here),
- // but not yet published the app domain.
- // _ASSERTE(!"D::RADFIPC: trying to remove an AppDomain that was never added");
- hr = (E_FAIL);
- goto ErrExit;
- }
-
- // Release the entry
- m_pAppDomainCB->FreeEntry(pADInfo);
-
-ErrExit:
- // UnLock the list
- m_pAppDomainCB->Unlock();
-
- //
- // The Debugger expects to never get an unload event for the default AppDomain.
- //
-
- return hr;
-}
-
-/******************************************************************************
- * Update the AppDomain in the list stored in the IPC block.
- ******************************************************************************/
-HRESULT Debugger::UpdateAppDomainEntryInIPC(AppDomain *pAppDomain)
-{
- CONTRACTL
- {
- NOTHROW;
- if (GetThreadNULLOk()) { GC_TRIGGERS;} else {DISABLED(GC_NOTRIGGER);}
- }
- CONTRACTL_END;
-
- HRESULT hr = S_OK;
- LPCWSTR szName = NULL;
-
- LOG((LF_CORDB, LL_INFO100,
- "D::UADEIIPC: Executing UpdateAppDomainEntryInIPC ad:0x%x.\n",
- pAppDomain));
-
- // if none of the slots are occupied, then simply return.
- if (m_pAppDomainCB->m_iNumOfUsedSlots == 0)
- return (E_FAIL);
-
- // Lock the list
- if (!m_pAppDomainCB->Lock())
- return (E_FAIL);
-
- // Look up the info entry
- AppDomainInfo *pADInfo = m_pAppDomainCB->FindEntry(pAppDomain);
-
- if (!pADInfo)
- {
- hr = E_FAIL;
- goto ErrExit;
- }
-
- // Update the name only if new name is non-null
- szName = pADInfo->m_pAppDomain->GetFriendlyNameForDebugger();
- pADInfo->SetName(szName);
-
-ErrExit:
- // UnLock the list
- m_pAppDomainCB->Unlock();
-
- return hr;
-}
-
-/******************************************************************************
- *
- ******************************************************************************/
-HRESULT Debugger::InitAppDomainIPC(void)
-{
- CONTRACTL
- {
- THROWS;
- GC_NOTRIGGER;
-
- PRECONDITION(CheckPointer(m_pAppDomainCB));
- }
- CONTRACTL_END;
-
- // Ensure that if we throw here, the Terminate will get called and cleanup all resources.
- // This will make Init an atomic operation - it either fully inits or fully fails.
- class EnsureCleanup
- {
- Debugger * m_pThis;
-
- public:
- EnsureCleanup(Debugger * pThis)
- {
- m_pThis = pThis;
- }
-
- void SuppressCleanup()
- {
- m_pThis = NULL;
- }
-
- ~EnsureCleanup()
- {
- if (m_pThis != NULL)
- {
- m_pThis->TerminateAppDomainIPC();
- }
- }
- } hEnsureCleanup(this);
-
- DWORD dwStrLen = 0;
- SString szExeName;
- int i;
-
- // all fields in the object can be zero initialized.
- // If we throw, before fully initializing this, then cleanup won't try to free
- // uninited values.
- ZeroMemory(m_pAppDomainCB, sizeof(*m_pAppDomainCB));
-
- // Create a mutex to allow the Left and Right Sides to properly
- // synchronize. The Right Side will spin until m_hMutex is valid,
- // then it will acquire it before accessing the data.
- HandleHolder hMutex(CreateMutex(NULL, TRUE/*hold*/, NULL));
- if (hMutex == NULL)
- {
- ThrowLastError();
- }
- if (!m_pAppDomainCB->m_hMutex.SetLocal(hMutex))
- {
- ThrowLastError();
- }
- hMutex.SuppressRelease();
-
- m_pAppDomainCB->m_iSizeInBytes = INITIAL_APP_DOMAIN_INFO_LIST_SIZE *
- sizeof (AppDomainInfo);
-
- // Number of slots in AppDomainListElement array
- m_pAppDomainCB->m_rgListOfAppDomains = new AppDomainInfo[INITIAL_APP_DOMAIN_INFO_LIST_SIZE];
- _ASSERTE(m_pAppDomainCB->m_rgListOfAppDomains != NULL); // throws on oom
-
-
- m_pAppDomainCB->m_iTotalSlots = INITIAL_APP_DOMAIN_INFO_LIST_SIZE;
-
- // Initialize each AppDomainListElement
- for (i = 0; i < INITIAL_APP_DOMAIN_INFO_LIST_SIZE; i++)
- {
- m_pAppDomainCB->m_rgListOfAppDomains[i].FreeEntry();
- }
-
- // also initialize the process name
- dwStrLen = WszGetModuleFileName(NULL,
- szExeName);
-
-
- // If we couldn't get the name, then use a nice default.
- if (dwStrLen == 0)
- {
- szExeName.Set(W(""));
- dwStrLen = szExeName.GetCount();
- }
-
- // If we got the name, copy it into a buffer. dwStrLen is the
- // count of characters in the name, not including the null
- // terminator.
- m_pAppDomainCB->m_szProcessName = new WCHAR[dwStrLen + 1];
- _ASSERTE(m_pAppDomainCB->m_szProcessName != NULL); // throws on oom
-
- wcscpy_s(m_pAppDomainCB->m_szProcessName, dwStrLen + 1, szExeName);
-
- // Add 1 to the string length so the Right Side will copy out the
- // null terminator, too.
- m_pAppDomainCB->m_iProcessNameLengthInBytes = (dwStrLen + 1) * sizeof(WCHAR);
-
- if (m_pAppDomainCB->m_hMutex != NULL)
- {
- m_pAppDomainCB->Unlock();
- }
-
- hEnsureCleanup.SuppressCleanup();
- return S_OK;
-}
-
-/******************************************************************************
- * Uninitialize the AppDomain IPC block
- * Returns:
- * S_OK -if fully uninitialized
- * E_FAIL - if we can't get ownership of the block, and thus no uninitialization
- * work is done.
- ******************************************************************************/
-HRESULT Debugger::TerminateAppDomainIPC(void)
-{
- CONTRACTL
- {
- NOTHROW;
- GC_NOTRIGGER;
- }
- CONTRACTL_END;
-
- // If we have no AppDomain block, then we can consider it's already terminated.
- if (m_pAppDomainCB == NULL)
- return S_OK;
-
- HRESULT hr = S_OK;
-
- // Lock the list
- // If there's no mutex, then we're in a partially created state.
- // This means InitAppDomainIPC failed halfway through. But we're still thread safe
- // since other threads can't access us if we don't have the mutex.
- if ((m_pAppDomainCB->m_hMutex != NULL) && !m_pAppDomainCB->Lock())
- {
- // The callers don't check our return value, we may want to know when we can't gracefully clean up
- LOG((LF_CORDB, LL_INFO10, "Debugger::TerminateAppDomainIPC: Failed to get AppDomain IPC lock, not cleaning up.\n"));
-
- // If the lock is valid, but we can't get it, then we can't really
- // uninitialize since someone else is using the block.
- return (E_FAIL);
- }
-
- // The shared IPC segment could still be around after the debugger
- // object has been destroyed during process shutdown. So, reset
- // the UsedSlots count to 0 so that any out of process clients
- // enumeratingthe app domains in this process see 0 AppDomains.
- m_pAppDomainCB->m_iNumOfUsedSlots = 0;
- m_pAppDomainCB->m_iTotalSlots = 0;
-
- // Now delete the memory allocated for AppDomainInfo array
- delete [] m_pAppDomainCB->m_rgListOfAppDomains;
- m_pAppDomainCB->m_rgListOfAppDomains = NULL;
-
- delete [] m_pAppDomainCB->m_szProcessName;
- m_pAppDomainCB->m_szProcessName = NULL;
- m_pAppDomainCB->m_iProcessNameLengthInBytes = 0;
-
- // Set the mutex handle to NULL.
- // If the Right Side acquires the mutex, it will verify
- // that the handle is still not NULL. If it is, then it knows it
- // really lost.
- RemoteHANDLE m = m_pAppDomainCB->m_hMutex;
- m_pAppDomainCB->m_hMutex.m_hLocal = NULL;
-
- // And bring us back to a fully uninitialized state.
- ZeroMemory(m_pAppDomainCB, sizeof(*m_pAppDomainCB));
-
- // We're done. release and close the mutex. Note that this must be done
- // after we clear it out above to ensure there is no race condition.
- if( m != NULL )
- {
- VERIFY(ReleaseMutex(m));
- m.Close();
- }
-
- return hr;
-}
-
-
#ifndef DACCESS_COMPILE
//
diff --git a/src/coreclr/debug/ee/debugger.h b/src/coreclr/debug/ee/debugger.h
index 0e141c94a14e1e..403add11227084 100644
--- a/src/coreclr/debug/ee/debugger.h
+++ b/src/coreclr/debug/ee/debugger.h
@@ -1116,8 +1116,8 @@ class DebuggerMethodInfo
// different part of the address space (not on the heap).
// ------------------------------------------------------------------------ */
-constexpr uint64_t DBG_MAX_EXECUTABLE_ALLOC_SIZE=112;
-constexpr uint64_t EXPECTED_CHUNKSIZE=128;
+constexpr uint64_t DBG_MAX_EXECUTABLE_ALLOC_SIZE=120; // sizeof (SharedPatchBypassBuffer)
+constexpr uint64_t EXPECTED_CHUNKSIZE=256; // This must be a power of 2. It represents the size of DebuggerHeapExecutableMemoryChunk, can be the sizeof (DataChunk) or sizeof (BookkeepingChunk). Changes to DBG_MAX_EXECUTABLE_ALLOC_SIZE can affect this number. Currently we require 136 bytes, and so the closest power of 2 is 256.
constexpr uint64_t DEBUGGERHEAP_PAGESIZE=4096;
constexpr uint64_t CHUNKS_PER_DEBUGGERHEAP=(DEBUGGERHEAP_PAGESIZE / EXPECTED_CHUNKSIZE);
constexpr uint64_t MAX_CHUNK_MASK=((1ull << CHUNKS_PER_DEBUGGERHEAP) - 1);
@@ -2105,6 +2105,7 @@ class Debugger : public DebugInterface
HRESULT GetILToNativeMapping(PCODE pNativeCodeStartAddress, ULONG32 cMap, ULONG32 *pcMap,
COR_DEBUG_IL_TO_NATIVE_MAP map[]);
+#ifdef DEBUG
HRESULT GetILToNativeMappingIntoArrays(
MethodDesc * pMethodDesc,
PCODE pNativeCodeStartAddress,
@@ -2112,6 +2113,7 @@ class Debugger : public DebugInterface
USHORT * pcMap,
UINT ** prguiILOffset,
UINT ** prguiNativeOffset);
+#endif // DEBUG
PRD_TYPE GetPatchedOpcode(CORDB_ADDRESS_TYPE *ip);
BOOL CheckGetPatchedOpcode(CORDB_ADDRESS_TYPE *address, /*OUT*/ PRD_TYPE *pOpcode);
@@ -2615,14 +2617,7 @@ class Debugger : public DebugInterface
BOOL ShouldAutoAttach();
BOOL FallbackJITAttachPrompt();
- HRESULT AddAppDomainToIPC (AppDomain *pAppDomain);
- HRESULT RemoveAppDomainFromIPC (AppDomain *pAppDomain);
- HRESULT UpdateAppDomainEntryInIPC (AppDomain *pAppDomain);
-
- void SendCreateAppDomainEvent(AppDomain * pAppDomain);
-
- // Notify the debugger that an assembly has been loaded
- void LoadAssembly(DomainAssembly * pDomainAssembly);
+ void AppDomainCreated(AppDomain * pAppDomain);
// Notify the debugger that an assembly has been unloaded
void UnloadAssembly(DomainAssembly * pDomainAssembly);
@@ -2838,9 +2833,6 @@ class Debugger : public DebugInterface
DebuggerLaunchSetting GetDbgJITDebugLaunchSetting();
public:
- HRESULT InitAppDomainIPC(void);
- HRESULT TerminateAppDomainIPC(void);
-
bool ResumeThreads(AppDomain* pAppDomain);
void ProcessAnyPendingEvals(Thread *pThread);
@@ -2921,7 +2913,6 @@ class Debugger : public DebugInterface
Volatile m_jitAttachInProgress;
BOOL m_launchingDebugger;
BOOL m_LoggingEnabled;
- AppDomainEnumerationIPCBlock *m_pAppDomainCB;
LONG m_dClassLoadCallbackCount;
diff --git a/src/coreclr/debug/ee/frameinfo.cpp b/src/coreclr/debug/ee/frameinfo.cpp
index 7060087ac24afc..c313c648f27cc9 100644
--- a/src/coreclr/debug/ee/frameinfo.cpp
+++ b/src/coreclr/debug/ee/frameinfo.cpp
@@ -1503,7 +1503,7 @@ StackWalkAction DebuggerWalkStackProc(CrawlFrame *pCF, void *data)
(pPrevFrame->GetFrameType() == Frame::TYPE_EXIT) &&
!HasExitRuntime(pPrevFrame, d, NULL) )
{
- // This is for the inlined NDirectMethodFrameGeneric case. We have not exit the runtime yet, so the current
+ // This is for the inlined PInvokeMethodFrameGeneric case. We have not exit the runtime yet, so the current
// frame should still be regarded as the leaf frame.
d->info.fIsLeaf = true;
}
diff --git a/src/coreclr/debug/ee/functioninfo.cpp b/src/coreclr/debug/ee/functioninfo.cpp
index 6e2db4cab721a1..191cc7c278b00b 100644
--- a/src/coreclr/debug/ee/functioninfo.cpp
+++ b/src/coreclr/debug/ee/functioninfo.cpp
@@ -920,6 +920,7 @@ void DebuggerJitInfo::LazyInitBounds()
BOOL fSuccess = DebugInfoManager::GetBoundariesAndVars(
request,
InteropSafeNew, NULL, // allocator
+ BoundsType::Instrumented, // TODO We currently don't use the uninstrumented bounds here but we should and remove the instrumented bounds logic from the SetBoundaries function.
&cMap, &pMap,
&cVars, &pVars);
@@ -1045,6 +1046,12 @@ void DebuggerJitInfo::SetBoundaries(ULONG32 cMap, ICorDebugInfo::OffsetMapping *
DebuggerILToNativeMap *m = m_sequenceMap;
+ // TODO: Consider removing the handling for the InstrumentedILMap here.
+ // since we now have the ability to get an uninstrumented IL offset mapping
+ // directly from the VM. This work was not done when adding the instrumented
+ // IL mapping due to the work ocurring too close to the shipping deadline for .NET 10.
+ // If we do so, we need to change the input to this function to be the uninstrumented IL offset mapping
+
// For the instrumented-IL case, we need to remove all duplicate entries.
// So we keep a record of the last old IL offset. If the current old IL
// offset is the same as the last old IL offset, we remove it.
diff --git a/src/coreclr/debug/ee/walker.h b/src/coreclr/debug/ee/walker.h
index 63bd4cfa2fd273..4dcae6d75ed273 100644
--- a/src/coreclr/debug/ee/walker.h
+++ b/src/coreclr/debug/ee/walker.h
@@ -62,6 +62,8 @@ struct InstructionAttribute
}
};
+#ifndef DACCESS_COMPILE
+
/* ------------------------------------------------------------------------- *
* Classes
* ------------------------------------------------------------------------- */
@@ -280,4 +282,6 @@ class NativeWalker : public Walker
};
#endif
+#endif // DACCESS_COMPILE
+
#endif // WALKER_H_
diff --git a/src/coreclr/debug/inc/dacdbiinterface.h b/src/coreclr/debug/inc/dacdbiinterface.h
index b4b5c4b006ccf1..66b33aab1fa51d 100644
--- a/src/coreclr/debug/inc/dacdbiinterface.h
+++ b/src/coreclr/debug/inc/dacdbiinterface.h
@@ -2729,6 +2729,9 @@ class IDacDbiInterface
virtual
bool MetadataUpdatesApplied() = 0;
+ virtual
+ HRESULT GetDomainAssemblyFromModule(VMPTR_Module vmModule, OUT VMPTR_DomainAssembly *pVmDomainAssembly) = 0;
+
// The following tag tells the DD-marshalling tool to stop scanning.
// END_MARSHAL
diff --git a/src/coreclr/debug/inc/dbgappdomain.h b/src/coreclr/debug/inc/dbgappdomain.h
index de8a06b38c9e51..1e77c89d71ee0f 100644
--- a/src/coreclr/debug/inc/dbgappdomain.h
+++ b/src/coreclr/debug/inc/dbgappdomain.h
@@ -140,239 +140,6 @@ struct RemoteHANDLE {
}
};
-
-// AppDomain publishing server support:
-// Information about all appdomains in the process will be maintained
-// in the shared memory block for use by the debugger, etc.
-// This structure defines the layout of the information that will
-// be maintained.
-struct AppDomainEnumerationIPCBlock
-{
- // !!! The binary format of this layout must remain the same across versions so that
- // !!! a V2.0 publisher can inspect a v1.0 app.
-
- // lock for serialization while manipulating AppDomain list.
- RemoteHANDLE m_hMutex;
-
- // Number of slots in AppDomainListElement array
- int m_iTotalSlots;
- int m_iNumOfUsedSlots;
- int m_iLastFreedSlot;
- int m_iSizeInBytes; // Size of AppDomainInfo in bytes
-
- // We can use psapi!GetModuleFileNameEx to get the module name.
- // This provides an alternative.
- int m_iProcessNameLengthInBytes;
- WCHAR *m_szProcessName;
-
- AppDomainInfo *m_rgListOfAppDomains;
- BOOL m_fLockInvalid;
-
-
-#ifndef RIGHT_SIDE_COMPILE
- /*************************************************************************
- * Locks the list
- *************************************************************************/
- BOOL Lock()
- {
- DWORD dwRes = WaitForSingleObject(m_hMutex, 3000);
- if (dwRes == WAIT_TIMEOUT)
- {
- // Nobody should get stuck holding this lock.
- // If we timeout on the wait, then either:
- // - it's a really bad race and somebody got preempted for a long time
- // - perhaps somebody's doing a DOS attack and holding onto the mutex.
- m_fLockInvalid = TRUE;
- }
-
-
- // The only time this can happen is if we're in shutdown and a thread
- // that held this lock is killed. If this happens, assume that this
- // IPC block is in an invalid state and return FALSE to indicate
- // that people shouldn't do anything with the block anymore.
- if (dwRes == WAIT_ABANDONED)
- {
- m_fLockInvalid = TRUE;
- }
-
- if (m_fLockInvalid)
- {
- Unlock();
- }
-
- return (dwRes == WAIT_OBJECT_0 && !m_fLockInvalid);
- }
-
- /*************************************************************************
- * Unlocks the list
- *************************************************************************/
- void Unlock()
- {
- // Lock may or may not be valid at this point. Thus Release may fail,
- // but we'll just ignore that.
- ReleaseMutex(m_hMutex);
- }
-
- /*************************************************************************
- * Gets a free AppDomainInfo entry, and will allocate room if there are
- * no free slots left.
- *************************************************************************/
- AppDomainInfo *GetFreeEntry()
- {
- // first check to see if there is space available. If not, then realloc.
- if (m_iNumOfUsedSlots == m_iTotalSlots)
- {
- // need to realloc
- AppDomainInfo *pTemp =
- new (nothrow) AppDomainInfo [m_iTotalSlots*2];
-
- if (pTemp == NULL)
- {
- return (NULL);
- }
-
- memcpy (pTemp, m_rgListOfAppDomains, m_iSizeInBytes);
-
- delete [] m_rgListOfAppDomains;
-
- // Initialize the increased portion of the realloced memory
- int iNewSlotSize = m_iTotalSlots * 2;
-
- for (int iIndex = m_iTotalSlots; iIndex < iNewSlotSize; iIndex++)
- pTemp[iIndex].FreeEntry();
-
- m_rgListOfAppDomains = pTemp;
- m_iTotalSlots = iNewSlotSize;
- m_iSizeInBytes *= 2;
- }
-
- // Walk the list looking for an empty slot. Start from the last
- // one which was freed.
- {
- int i = m_iLastFreedSlot;
-
- do
- {
- // Pointer to the entry being examined
- AppDomainInfo *pADInfo = &(m_rgListOfAppDomains[i]);
-
- // is the slot available?
- if (pADInfo->IsEmpty())
- return (pADInfo);
-
- i = (i + 1) % m_iTotalSlots;
-
- } while (i != m_iLastFreedSlot);
- }
-
- _ASSERTE(!"ADInfo::GetFreeEntry: should never get here.");
- return (NULL);
- }
-
- /*************************************************************************
- * Returns an AppDomainInfo slot to the free list.
- *************************************************************************/
- void FreeEntry(AppDomainInfo *pADInfo)
- {
- _ASSERTE(pADInfo >= m_rgListOfAppDomains &&
- pADInfo < m_rgListOfAppDomains + m_iSizeInBytes);
- _ASSERTE(((size_t)pADInfo - (size_t)m_rgListOfAppDomains) %
- sizeof(AppDomainInfo) == 0);
-
- // Mark this slot as free
- pADInfo->FreeEntry();
-
-#ifdef _DEBUG
- *pADInfo = {};
-#endif
-
- // decrement the used slot count
- m_iNumOfUsedSlots--;
-
- // Save the last freed slot.
- m_iLastFreedSlot = (int)((size_t)pADInfo - (size_t)m_rgListOfAppDomains) /
- sizeof(AppDomainInfo);
- }
-
- /*************************************************************************
- * Finds an AppDomainInfo entry corresponding to the AppDomain pointer.
- * Returns NULL if no such entry exists.
- *************************************************************************/
- AppDomainInfo *FindEntry(AppDomain *pAD)
- {
- // Walk the list looking for a matching entry
- for (int i = 0; i < m_iTotalSlots; i++)
- {
- AppDomainInfo *pADInfo = &(m_rgListOfAppDomains[i]);
-
- if (!pADInfo->IsEmpty() &&
- pADInfo->m_pAppDomain == pAD)
- return pADInfo;
- }
-
- return (NULL);
- }
-
- /*************************************************************************
- * Returns the first AppDomainInfo entry in the list. Returns NULL if
- * no such entry exists.
- *************************************************************************/
- AppDomainInfo *FindFirst()
- {
- // Walk the list looking for a non-empty entry
- for (int i = 0; i < m_iTotalSlots; i++)
- {
- AppDomainInfo *pADInfo = &(m_rgListOfAppDomains[i]);
-
- if (!pADInfo->IsEmpty())
- return pADInfo;
- }
-
- return (NULL);
- }
-
- /*************************************************************************
- * Returns the next AppDomainInfo entry after pADInfo. Returns NULL if
- * pADInfo was the last in the list.
- *************************************************************************/
- AppDomainInfo *FindNext(AppDomainInfo *pADInfo)
- {
- _ASSERTE(pADInfo >= m_rgListOfAppDomains &&
- pADInfo < m_rgListOfAppDomains + m_iSizeInBytes);
- _ASSERTE(((size_t)pADInfo - (size_t)m_rgListOfAppDomains) %
- sizeof(AppDomainInfo) == 0);
-
- // Walk the list looking for the next non-empty entry
- for (int i = (int)((size_t)pADInfo - (size_t)m_rgListOfAppDomains)
- / sizeof(AppDomainInfo) + 1;
- i < m_iTotalSlots;
- i++)
- {
- AppDomainInfo *pADInfoTemp = &(m_rgListOfAppDomains[i]);
-
- if (!pADInfoTemp->IsEmpty())
- return pADInfoTemp;
- }
-
- return (NULL);
- }
-#endif // RIGHT_SIDE_COMPILE
-};
-
-// Enforce the AppDomain IPC block binary layout doesn't change between versions.
-// Only an issue for x86 since that's the only platform w/ multiple versions.
-#if defined(TARGET_X86)
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_hMutex) == 0x0);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_iTotalSlots) == 0x4);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_iNumOfUsedSlots) == 0x8);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_iLastFreedSlot) == 0xc);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_iSizeInBytes) == 0x10);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_iProcessNameLengthInBytes) == 0x14);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_szProcessName) == 0x18);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_rgListOfAppDomains) == 0x1c);
-static_assert_no_msg(offsetof(AppDomainEnumerationIPCBlock, m_fLockInvalid) == 0x20);
-#endif
-
#endif //DbgAppDomain_H
diff --git a/src/coreclr/debug/inc/dbgtargetcontext.h b/src/coreclr/debug/inc/dbgtargetcontext.h
index ea374cf8b6def6..606e4954b35272 100644
--- a/src/coreclr/debug/inc/dbgtargetcontext.h
+++ b/src/coreclr/debug/inc/dbgtargetcontext.h
@@ -474,7 +474,7 @@ typedef DECLSPEC_ALIGN(16) struct {
#if !defined(CROSS_COMPILE) && !defined(TARGET_WINDOWS)
-static_assert(sizeof(DT_CONTEXT) == offsetof(T_CONTEXT, XStateFeaturesMask), "DT_CONTEXT must not include the SVE registers on AMD64");
+static_assert(sizeof(DT_CONTEXT) == offsetof(T_CONTEXT, XStateFeaturesMask), "DT_CONTEXT must not include the SVE registers on ARM64");
#else
static_assert(sizeof(DT_CONTEXT) == sizeof(T_CONTEXT), "DT_CONTEXT size must equal the T_CONTEXT size on ARM64");
#endif
diff --git a/src/coreclr/debug/inc/dbgtransportsession.h b/src/coreclr/debug/inc/dbgtransportsession.h
index 3bc9521e9c5251..276bd00a6aa93b 100644
--- a/src/coreclr/debug/inc/dbgtransportsession.h
+++ b/src/coreclr/debug/inc/dbgtransportsession.h
@@ -341,7 +341,7 @@ class DbgTransportSession
#ifdef RIGHT_SIDE_COMPILE
HRESULT Init(const ProcessDescriptor& pd, HANDLE hProcessExited);
#else
- HRESULT Init(DebuggerIPCControlBlock * pDCB, AppDomainEnumerationIPCBlock * pADB);
+ HRESULT Init(DebuggerIPCControlBlock * pDCB);
#endif // RIGHT_SIDE_COMPILE
// Drive the session to the SS_Closed state, which will deallocate all remaining transport resources
@@ -426,9 +426,6 @@ class DbgTransportSession
HRESULT GetDCB(DebuggerIPCControlBlock *pDCB);
HRESULT SetDCB(DebuggerIPCControlBlock *pDCB);
- // Read the AppDomain control block on the LS from the RS.
- HRESULT GetAppDomainCB(AppDomainEnumerationIPCBlock *pADB);
-
#endif // RIGHT_SIDE_COMPILE
private:
@@ -469,7 +466,6 @@ class DbgTransportSession
MT_WriteMemory, // RS <-> LS : RS wants to write LS memory block (or LS is replying to such a request)
MT_GetDCB, // RS <-> LS : RS wants to read LS DCB (or LS is replying to such a request)
MT_SetDCB, // RS <-> LS : RS wants to write LS DCB (or LS is replying to such a request)
- MT_GetAppDomainCB, // RS <-> LS : RS wants to read LS AppDomainCB (or LS is replying to such a request)
};
// Reasons the LS can give for rejecting a session. These codes should *not* be changed other than by
@@ -589,7 +585,6 @@ class DbgTransportSession
LONG m_cSentWriteMemory;
LONG m_cSentGetDCB;
LONG m_cSentSetDCB;
- LONG m_cSentGetAppDomainCB;
LONG m_cSentDDMessage;
// Message type counts for receives.
@@ -603,7 +598,6 @@ class DbgTransportSession
LONG m_cReceivedWriteMemory;
LONG m_cReceivedGetDCB;
LONG m_cReceivedSetDCB;
- LONG m_cReceivedGetAppDomainCB;
LONG m_cReceivedDDMessage;
// Low level block counts.
@@ -747,7 +741,6 @@ class DbgTransportSession
// The LS requires the addresses of a couple of runtime data structures in order to service MT_GetDCB etc.
// These are provided by the runtime at initialization time.
DebuggerIPCControlBlock *m_pDCB;
- AppDomainEnumerationIPCBlock *m_pADB;
#endif // !RIGHT_SIDE_COMPILE
HRESULT SendEventWorker(DebuggerIPCEvent * pEvent, IPCEventType type);
diff --git a/src/coreclr/debug/runtimeinfo/CMakeLists.txt b/src/coreclr/debug/runtimeinfo/CMakeLists.txt
index 1d0abd332c6011..a31d4b6f9812c3 100644
--- a/src/coreclr/debug/runtimeinfo/CMakeLists.txt
+++ b/src/coreclr/debug/runtimeinfo/CMakeLists.txt
@@ -38,67 +38,3 @@ endif()
# publish runtimeinfo lib
install_clr(TARGETS runtimeinfo DESTINATIONS lib COMPONENT runtime)
-
-
-# cDAC contract descriptor
-
-if(CDAC_BUILD_TOOL_BINARY_PATH AND "${CLR_DOTNET_RID}" STREQUAL "")
- message(FATAL_ERROR "CLR_DOTNET_RID is not set. Please ensure it is being set to the portable RID of the target platform by runtime.proj.")
-endif()
-configure_file(configure.h.in ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
-
-if (NOT CDAC_BUILD_TOOL_BINARY_PATH)
- # if CDAC_BUILD_TOOL_BINARY_PATH is unspecified (for example for a build without a .NET SDK or msbuild),
- # link a stub contract descriptor into the runtime
- add_library_clr(cdac_contract_descriptor OBJECT contractdescriptorstub.c)
- message(STATUS "Using a stub cDAC contract descriptor")
-else()
- # generate a contract descriptor using cdac-build-tool from a data descriptor and contract json file
-
- add_library(cdac_data_descriptor OBJECT datadescriptor.cpp)
- # don't build the data descriptor before the VM (and any of its dependencies' generated headers)
- add_dependencies(cdac_data_descriptor cee_wks_core)
- if(CLR_CMAKE_TARGET_WIN32)
- # turn off whole program optimization:
- # 1. it creates object files that cdac-build-tool can't read
- # 2. we never link cdac_data_descriptor into the final product - it's only job is to be scraped
- set_target_properties(cdac_data_descriptor PROPERTIES
- INTERPROCEDURAL_OPTIMIZATION_RELEASE OFF
- INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO OFF)
- endif()
- target_include_directories(cdac_data_descriptor BEFORE PRIVATE ${VM_DIR})
- target_include_directories(cdac_data_descriptor BEFORE PRIVATE ${VM_DIR}/${ARCH_SOURCES_DIR})
- target_include_directories(cdac_data_descriptor PRIVATE ${CLR_DIR}/interop/inc)
-
- set(GENERATED_CDAC_DESCRIPTOR_DIR "${CMAKE_CURRENT_BINARY_DIR}/cdac")
- set(CONTRACT_DESCRIPTOR_OUTPUT "${GENERATED_CDAC_DESCRIPTOR_DIR}/contract-descriptor.c")
- if(NOT EXISTS "${CDAC_BUILD_TOOL_BINARY_PATH}")
- message(FATAL_ERROR "${CDAC_BUILD_TOOL_BINARY_PATH} does not exist")
- endif()
- set(CONTRACT_DESCRIPTOR_INPUT "${CMAKE_CURRENT_SOURCE_DIR}/contract-descriptor.c.in")
-
- set(CONTRACT_BASELINE_DIR "${CLR_REPO_ROOT_DIR}/docs/design/datacontracts/data")
- set(CONTRACT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/contracts.jsonc")
-
- # generate the contract descriptor by running cdac-build-tool
- # n.b. this just uses `dotnet` from the PATH. InitializeDotNetCli adds the apropropriate directory
- add_custom_command(
- OUTPUT "${CONTRACT_DESCRIPTOR_OUTPUT}"
- VERBATIM
- COMMAND ${CLR_DOTNET_HOST_PATH} ${CDAC_BUILD_TOOL_BINARY_PATH} compose -i "${CONTRACT_DESCRIPTOR_INPUT}" -o "${CONTRACT_DESCRIPTOR_OUTPUT}" -b "${CONTRACT_BASELINE_DIR}" -c "${CONTRACT_FILE}" $