diff options
| author | Jan Kotas <jkotas@microsoft.com> | 2020-12-08 21:40:17 +0300 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2020-12-08 21:40:17 +0300 |
| commit | 10381a2cdc33860f0dc649b24cbb703d23b9ea33 (patch) | |
| tree | c9cd0264332f0f8d22df457db4ce5ef2bb5bba1f | |
| parent | 18d1527c079e5f4c1e3ee0ccd1ca22f92f7969c9 (diff) | |
Find&Replace coreclr/src -> coreclr (#45761)
119 files changed, 195 insertions, 195 deletions
diff --git a/.gitattributes b/.gitattributes index 04518684225..b4e3bcd0745 100644 --- a/.gitattributes +++ b/.gitattributes @@ -67,8 +67,8 @@ *.h linguist-language=C # CLR specific -src/coreclr/src/pal/tests/palsuite/paltestlist.txt text eol=lf -src/coreclr/src/pal/tests/palsuite/paltestlist_to_be_reviewed.txt text eol=lf +src/coreclr/pal/tests/palsuite/paltestlist.txt text eol=lf +src/coreclr/pal/tests/palsuite/paltestlist_to_be_reviewed.txt text eol=lf src/tests/JIT/Performance/CodeQuality/BenchmarksGame/regex-redux/regexdna-input25.txt text eol=lf src/tests/JIT/Performance/CodeQuality/BenchmarksGame/regex-redux/regexdna-input25000.txt text eol=lf src/tests/JIT/Performance/CodeQuality/BenchmarksGame/reverse-complement/revcomp-input25.txt text eol=lf diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index f970427a97e..4aeb19e35f9 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -9,9 +9,9 @@ # CoreCLR Code Owners -/src/coreclr/src/inc/corinfo.h @dotnet/jit-contrib -/src/coreclr/src/inc/corjit.h @dotnet/jit-contrib -/src/coreclr/src/jit/ @dotnet/jit-contrib +/src/coreclr/inc/corinfo.h @dotnet/jit-contrib +/src/coreclr/inc/corjit.h @dotnet/jit-contrib +/src/coreclr/jit/ @dotnet/jit-contrib # Mono Code Owners diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index a8cf7c3ce6d..fd80057e8f3 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -107,7 +107,7 @@ The following file header is the used for .NET Core. Please use it for new files // The .NET Foundation licenses this file to you under the MIT license. ``` -- See [class.cpp](./src/coreclr/src/vm/class.cpp) for an example of the header in a C++ file. +- See [class.cpp](./src/coreclr/vm/class.cpp) for an example of the header in a C++ file. - See [List.cs](./src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs) for an example of the header in a C# file. ## PR - CI Process diff --git a/docs/README.md b/docs/README.md index bbbc1515913..023cb7b5686 100644 --- a/docs/README.md +++ b/docs/README.md @@ -71,6 +71,6 @@ Other Information - [.NET Filename Encyclopedia](project/dotnet-filenames.md) - [Porting to .NET Core](https://docs.microsoft.com/en-us/dotnet/standard/analyzers/portability-analyzer) - [.NET Standards (Ecma)](project/dotnet-standards.md) -- [CLR Configuration Knobs](../src/coreclr/src/inc/clrconfigvalues.h) +- [CLR Configuration Knobs](../src/coreclr/inc/clrconfigvalues.h) - [CLR overview](https://docs.microsoft.com/dotnet/standard/clr) - [Wikipedia Entry for the CLR](https://en.wikipedia.org/wiki/Common_Language_Runtime) diff --git a/docs/coding-guidelines/EventLogging.md b/docs/coding-guidelines/EventLogging.md index f2063a1a5c1..8d581cb2925 100644 --- a/docs/coding-guidelines/EventLogging.md +++ b/docs/coding-guidelines/EventLogging.md @@ -6,9 +6,9 @@ Event Logging is a mechanism by which CoreClr can provide a variety of informati # Adding Events to the Runtime -- Edit the [Event manifest](../../src/coreclr/src/vm/ClrEtwAll.man) to add a new event. For guidelines on adding new events, take a look at the existing events in the manifest and this guide for [ETW Manifests](https://msdn.microsoft.com/en-us/library/dd996930%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396). +- Edit the [Event manifest](../../src/coreclr/vm/ClrEtwAll.man) to add a new event. For guidelines on adding new events, take a look at the existing events in the manifest and this guide for [ETW Manifests](https://msdn.microsoft.com/en-us/library/dd996930%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396). - The build system should automatically generate the required artifacts for the added events. -- Add entries in the [exclusion list](../../src/coreclr/src/vm/ClrEtwAllMeta.lst) if necessary +- Add entries in the [exclusion list](../../src/coreclr/vm/ClrEtwAllMeta.lst) if necessary - The Event Logging Mechanism provides the following two functions, which can be used within the VM: - **FireEtw**EventName, this is used to trigger the event - **EventEnabled**EventName, this is used to see if any consumer has subscribed to this event @@ -16,4 +16,4 @@ Event Logging is a mechanism by which CoreClr can provide a variety of informati # Adding New Logging System -Though the the Event logging system was designed for ETW, the build system provides a mechanism, basically an [adapter script- genEventing.py](../../src/coreclr/src/scripts/genEventing.py) so that other Logging System can be added and used by CoreClr. An Example of such an extension for [LTTng logging system](https://lttng.org/) can be found in [genLttngProvider.py](../../src/coreclr/src/scripts/genLttngProvider.py ) +Though the the Event logging system was designed for ETW, the build system provides a mechanism, basically an [adapter script- genEventing.py](../../src/coreclr/scripts/genEventing.py) so that other Logging System can be added and used by CoreClr. An Example of such an extension for [LTTng logging system](https://lttng.org/) can be found in [genLttngProvider.py](../../src/coreclr/scripts/genLttngProvider.py ) diff --git a/docs/coding-guidelines/clr-code-guide.md b/docs/coding-guidelines/clr-code-guide.md index 9818c1163f8..ece1900b3f4 100644 --- a/docs/coding-guidelines/clr-code-guide.md +++ b/docs/coding-guidelines/clr-code-guide.md @@ -105,7 +105,7 @@ Rules can either be imposed by invariants or team policy. Team policy rules are not necessarily less important than invariants. For example, the rule to use [safemath.h][safemath.h] rather that coding your own integer overflow check is a policy rule. But because it deals with security, we'd probably treat it as higher priority than a very obscure (non-security) related bug. -[safemath.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/safemath.h +[safemath.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/safemath.h One type of rule you won't find here are purely syntactic "code formatting" rules such as brace placement. While there is value in uniform stylistic conventions, we don't want to "lay down the law" on these to the extent that we do for the more semantic-oriented issues covered here. The rules included in this document are here because breaking them would do one of the following: @@ -238,8 +238,8 @@ The solution is the OBJECTHANDLE. OBJECTHANDLE allocates a location from special Handles are implemented through several layers of abstraction – the "official" interface for public use is the one described here and is exposed through [objecthandle.h][objecthandle.h]. Don't confuse this with [handletable.h][handletable.h] which contains the internals. The CreateHandle() api allocates a new location. ObjectFromHandle() dereferences the handle and returns an up-to-date reference. DestroyHandle() frees the location. -[objecthandle.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/gc/objecthandle.h -[handletable.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/gc/handletable.h +[objecthandle.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/gc/objecthandle.h +[handletable.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/gc/handletable.h The following code fragment shows how handles are used. In practice, of course, people use GCPROTECT rather than handles for situations this simple. @@ -551,7 +551,7 @@ First, look for a prebaked holder that does what you want. Some common ones are If no existing holder fits your need, make one. If it's your first holder, start by reading [src\inc\holder.h][holder.h]. Decide if you want a holder or a wrapper. If you don't do much with a resource except acquire and release it, use a holder. Otherwise, you want the wrapper since its overloaded operators make it much easier to replace the resource variable with the wrapper. -[holder.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/holder.h +[holder.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/holder.h Instantiate the holder or wrapper template with the required parameters. You must supply the data type being managed, the RELEASE function, the default value for uninitialized constructions, the IS_NULL function and the ACQUIRE function. Unless you're implementing a critical section holder, you can probably supply a NOP for ACQUIRE . Most resources can't be meaningfully released and reacquired so it's easier to allocate the resource outside the holder and pass it in through its constructor. For convenience, [holder.h][holder.h] defines a DoNothing<Type> template that creates a NOP ACQUIRE function for any given resource type. There are also convenience templates for writing RELEASE functions. See [holder.h][holder.h] for their definitions and examples of their use. @@ -716,7 +716,7 @@ SString is the abstraction to use for unmanaged strings in CLR code. It is impor This section will provide an overview for SString. For specific details on methods and use, see the file [src\inc\sstring.h][sstring.h]. SString has been in use in our codebase for quite a few years now so examples of its use should be easy to find. -[sstring.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/sstring.h +[sstring.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/sstring.h An SString object represents a Unicode string. It has its own buffer which it internally manages. The string buffer is typically not referenced directly by user code; instead the string is manipulated indirectly by methods defined on SString. Ultimately there are several ways to get at the raw string buffer if such functionality is needed to interface to existing APIs. But these should be used only when absolutely necessary. @@ -822,7 +822,7 @@ We used to assign levels manually, but this leads to problems when it comes time Instead we now record the explicit dependencies as a set of rules in the src\inc\CrstTypes.def file and use a tool to automatically assign compatible levels to each Crst type. See CrstTypes.def for a description of the rule syntax and other instructions for updating Crst types. -[crst.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/crst.h +[crst.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/crst.h ### <a name="2.6.3"></a>2.6.3 Creating Crsts @@ -1034,7 +1034,7 @@ Here are some immediate tips for working well with the managed-debugging service - GetFoo() - fails if a Foo does not exist. Being non-mutating, this should also be GC_NOTRIGGER. Non-mutating will also make it much easier to DAC-ize. This is what the debugger will call. - and GetOrCreateFoo() that is built around GetFoo(). The rest of the runtime can call this. - The debugger can then just call GetFoo(), and deal with the failure accordingly. -- If you add a new stub (or way to call managed code), make sure that you can source-level step-in (F11) it under the debugger. The debugger is not psychic. A source-level step-in needs to be able to go from the source-line before a call to the source-line after the call, or managed code developers will be very confused. If you make that call transition be a giant 500 line stub, you must cooperate with the debugger for it to know how to step-through it. (This is what StubManagers are all about. See [src\vm\stubmgr.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/stubmgr.h)). Try doing a step-in through your new codepath under the debugger. +- If you add a new stub (or way to call managed code), make sure that you can source-level step-in (F11) it under the debugger. The debugger is not psychic. A source-level step-in needs to be able to go from the source-line before a call to the source-line after the call, or managed code developers will be very confused. If you make that call transition be a giant 500 line stub, you must cooperate with the debugger for it to know how to step-through it. (This is what StubManagers are all about. See [src\vm\stubmgr.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/stubmgr.h)). Try doing a step-in through your new codepath under the debugger. - **Beware of timeouts** : The debugger may completely suspend your process at arbitrary points. In most cases, the debugger will do the right thing (and suspend your timeout too), but not always. For example, if you have some other process waiting for info from the debuggee, it [may hit a timeout](https://docs.microsoft.com/en-us/archive/blogs/jmstall/why-you-sometimes-get-a-bogus-contextswitchdeadlock-mda-under-the-debugger). - **Use CLR synchronization primitives (like Crst)**. In addition to all the reasons listed in the synchronization section, the CLR-aware primitives can cooperate with the debugging services. For example: - The debugger needs to know when threads are modifying sensitive data (which correlates to when the threads lock that data). @@ -1057,7 +1057,7 @@ Here are some immediate tips for working well with the managed-debugging service Because the CLR is ultimately compiled on several different platforms, we have to be careful about the primitive types which are used in our code. Some compilers can have slightly different declarations in standard header files, and different processor word sizes can require values to have different representations on different platforms. -Because of this, we have gathered definition all of the "blessed" CLR types in a single header file, [clrtypes.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/clrtypes.h). In general, you should only use primitive types which are defined in this file. As an exception, you may use built-in primitive types like int and short when precision isn't particularly interesting. +Because of this, we have gathered definition all of the "blessed" CLR types in a single header file, [clrtypes.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/clrtypes.h). In general, you should only use primitive types which are defined in this file. As an exception, you may use built-in primitive types like int and short when precision isn't particularly interesting. The types are grouped into several categories. @@ -1133,7 +1133,7 @@ This item asserts that the thread is in a particular mode or declares that the f #### <a name="2.10.1.5"></a>2.10.1.5 LOADS_TYPE(_loadlevel_) -This item asserts that the function may invoke the loader and cause a type to loaded up to (and including) the indicated loadlevel. Valid load levels are taken from ClassLoadLevel enumerationin [classLoadLevel.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/classloadlevel.h). +This item asserts that the function may invoke the loader and cause a type to loaded up to (and including) the indicated loadlevel. Valid load levels are taken from ClassLoadLevel enumerationin [classLoadLevel.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/classloadlevel.h). The CLR asserts if any attempt is made to load a type past the current limit set by LOADS_TYPE. A call to any function that has a LOADS_TYPE contract is treated as an attempt to load a type up to that limit. @@ -1143,7 +1143,7 @@ These declare whether a function or callee takes any kind of EE or user lock: Cr In TLS we keep track of the current intent (whether to lock), and actual reality (what locks are actually taken). Enforcement occurs as follows: -[contract.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/contract.h +[contract.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/contract.h - SCAN - A CANNOT_TAKE_LOCK function calling a CAN_TAKE_LOCK function is illegal (just like THROWS/NOTHROWS) @@ -1258,4 +1258,4 @@ At a high level, DAC is a technique to enable execution of CLR algorithms from o Various tools (most notably the debugger and SOS) rely on portions of the CLR code being properly "DACized". Writing code in this way can be tricky and error-prone. Use the following references for more details: -- The best documentation is in the code itself. See the large comments at the top of [src\inc\daccess.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/daccess.h). +- The best documentation is in the code itself. See the large comments at the top of [src\inc\daccess.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/daccess.h). diff --git a/docs/design/coreclr/botr/corelib.md b/docs/design/coreclr/botr/corelib.md index 288e4be0353..6f2ced10c98 100644 --- a/docs/design/coreclr/botr/corelib.md +++ b/docs/design/coreclr/botr/corelib.md @@ -36,7 +36,7 @@ To implement these, we need a way for the CLR to specify and optionally verify t The managed mechanism for calling into native code must also support the special managed calling convention used by `String`'s constructors, where the constructor allocates the memory used by the object (instead of the typical convention where the constructor is called after the GC allocates memory). -The CLR provides a [`mscorlib` binder](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/binder.cpp) internally, providing a mapping between unmanaged types and fields to managed types and fields. The binder will look up and load classes and allows the calling of managed methods. It also performs simple verification to ensure the correctness of any layout information specified in both managed and native code. The binder ensures that the managed class attempting to load exists in mscorlib, has been loaded, and the field offsets are correct. It also needs the ability to differentiate between method overloads with different signatures. +The CLR provides a [`mscorlib` binder](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/binder.cpp) internally, providing a mapping between unmanaged types and fields to managed types and fields. The binder will look up and load classes and allows the calling of managed methods. It also performs simple verification to ensure the correctness of any layout information specified in both managed and native code. The binder ensures that the managed class attempting to load exists in mscorlib, has been loaded, and the field offsets are correct. It also needs the ability to differentiate between method overloads with different signatures. # Calling from managed to native code @@ -70,7 +70,7 @@ The preferred types for QCall arguments are primitive types that are efficiently The pointers to common unmanaged EE structures should be wrapped into handle types. This is to make the managed implementation type safe and avoid falling into unsafe C# everywhere. See AssemblyHandle in [vm\qcall.h][qcall] for an example. -[qcall]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/qcall.h +[qcall]: https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/qcall.h Passing object references in and out of QCalls is done by wrapping a pointer to a local variable in a handle. It is intentionally cumbersome and should be avoided if reasonably possible. See the `StringHandleOnStack` in the example below. Returning objects, especially strings, from QCalls is the only common pattern where passing the raw objects is widely acceptable. (For reasoning on why this set of restrictions helps make QCalls less prone to GC holes, read the ["GC Holes, FCall, and QCall"](#gcholes) section below.) @@ -112,7 +112,7 @@ Do not replicate the comments into your actual QCall implementation. The QCall entrypoint has to be registered in tables in [vm\ecalllist.h][ecalllist] using `QCFuncEntry` macro. See ["Registering your QCall or FCall Method"](#register) below. -[ecalllist]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/ecalllist.h +[ecalllist]: https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/ecalllist.h ```C++ class FooNative @@ -173,7 +173,7 @@ FCalls allow more flexibility in terms of passing object references around, but FCalls require a lot of boilerplate code, too much to describe here. Refer to [fcall.h][fcall] for details. -[fcall]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/fcall.h +[fcall]: https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/fcall.h ### <a name="gcholes"></a> GC holes, FCall, and QCall @@ -193,7 +193,7 @@ The managed stack walker needs to be able to find its way from FCalls. It is rel Complex constructs like stack allocated objects with destructors or exception handling in the FCall implementation may confuse the epilog walker. This can lead to GC holes or crashes during stack walking. There is no comprehensive list of what constructs should be avoided to prevent this class of bugs. An FCall implementation that is fine one day may break with the next C++ compiler update. We depend on stress runs and code coverage to find bugs in this area. -Setting a breakpoint inside an FCall implementation may confuse the epilog walker. It leads to an "Invalid breakpoint in a helpermethod frame epilog" assert inside [vm\i386\gmsx86.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/i386/gmsx86.cpp). +Setting a breakpoint inside an FCall implementation may confuse the epilog walker. It leads to an "Invalid breakpoint in a helpermethod frame epilog" assert inside [vm\i386\gmsx86.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/i386/gmsx86.cpp). ### FCall example – managed @@ -287,7 +287,7 @@ The CLR provides a binder for this purpose. After you define your managed and na In [mscorlib.h][mscorlib.h], use macros ending in "_U" to describe a type, the name of fields in managed code, and the name of fields in a corresponding native data structure. Additionally, you can specify a list of methods, and reference them by name when you attempt to call them later. -[mscorlib.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/mscorlib.h +[mscorlib.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/mscorlib.h ``` C++ DEFINE_CLASS_U(SAFE_HANDLE, Interop, SafeHandle, SafeHandle) @@ -349,4 +349,4 @@ For QCalls, look in [qcall.h][qcall] for associated infrastructure, and [ecallli More general infrastructure and some native type definitions can be found in [object.h][object.h]. The binder uses `mscorlib.h` to associate managed and native classes. -[object.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/object.h +[object.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/object.h diff --git a/docs/design/coreclr/botr/dac-notes.md b/docs/design/coreclr/botr/dac-notes.md index 43b1714b1d8..497da0616e8 100644 --- a/docs/design/coreclr/botr/dac-notes.md +++ b/docs/design/coreclr/botr/dac-notes.md @@ -54,7 +54,7 @@ Marshaling Specifics DAC marshaling works through a collection of typedefs, macros and templated types that generally have one meaning in DAC builds and a different meaning in non-DAC builds. You can find these declarations in [src\inc\daccess.h][daccess.h]. You will also find a long comment at the beginning of this file that explains the details necessary to write code that uses the DAC. -[daccess.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/daccess.h +[daccess.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/daccess.h An example may be helpful in understanding how marshaling works. The common debugging scenario is represented in the following block diagram: @@ -139,8 +139,8 @@ Even better, in a DAC build, the DAC will automatically marshal variables, data The `GPTR` and `VPTR` macros are common enough to warrant special mention here. Both the way we use these and their external behavior is quite similar to `DPTR`s. Again, marshaling is automatic and transparent. The `VPTR` macro declares a marshaled pointer type for a class with virtual functions. This special macro is necessary because the virtual function table is essentially an implicit extra field. The DAC has to marshal this separately, since the function addresses are all target addresses that the DAC must convert to host addresses. Treating these classes in this way means that the DAC automatically instantiates the correct implementation class, making casts between base and derived types unnecessary. When you declare a `VPTR` type, you must also list it in [vptr_list.h][vptr_list.h]. `__GlobalPtr` types provide base functionality to marshal both global variables and static data members through the `GPTR`, `GVAL`, `SPTR` and `SVAL` macros. The implementation of global variables is almost identical to that of static fields (both use the `__GlobalPtr` class) and require the addition of an entry in [dacvars.h][dacvars.h]. The comments in [daccess.h][daccess.h] and [dacvars.h][dacvars.h] provide more details about declaring these types. -[dacvars.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/dacvars.h -[vptr_list.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/vptr_list.h +[dacvars.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/dacvars.h +[vptr_list.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/vptr_list.h Global and static values and pointers are interesting because they form the entry points to the target address space (all other uses of the DAC require you to have a target address already). Many of the globals in the runtime are already DACized. It occasionally becomes necessary to make a previously un-DACized (or a newly introduced) global available to the DAC. By using the appropriate macros and [dacvars.h][dacvars.h] entry, you enable a post-build step (DacTableGen.exe run by the build in ndp\clr\src\dacupdatedll) to save the address of the global (from clr.pdb) into a table that is embedded into mscordacwks.dll. The DAC uses this table at run-time to determine where to look in the target address space when the code accesses a global. @@ -205,7 +205,7 @@ When do you need to DACize? Whenever you add a new feature, you will need to consider its debuggability needs and DACize the code to support your feature. You must also ensure that any other changes, such as bug fixes or code clean-up, conform to the DAC rules when necessary. Otherwise, the changes will break the debugger or SOS. If you are simply modifying existing code (as opposed to implementing a new feature), you will generally be able to determine that you need to worry about the DAC when a function you modify includes a `SUPPORTS_DAC` contract. This contract has a few variants such as `SUPPORTS_DAC_WRAPPER` and `LEAF_DAC_CONTRACT`. You can find comments explaining the differences in [contract.h][contract.h]. If you see a number of DAC-specific types in the function, you should assume the code will run in DAC builds. -[contract.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/contract.h +[contract.h]: https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/contract.h DACizing ensures that code in the engine will work correctly with the DAC. It is important to use the DAC correctly to marshal values from the target to the host. Target addresses used incorrectly from the host (or vice versa) may reference unmapped addresses. If addresses are mapped, the values will be completely unrelated to the values expected. As a result, DACizing mostly involves ensuring that we use `PTR` types for all values that the DAC needs to marshal. Another major task is to ensure that we do not allow invasive code to execute in DAC builds. In practice, this means that we must sometimes refactor code or add `DACCESS_COMPILE` preprocessor directives. We also want to be sure that we add the appropriate `SUPPORTS_DAC` contract. The use of this contract signals to developers that the function works with the DAC. This is important for two reasons: diff --git a/docs/design/coreclr/botr/exceptions.md b/docs/design/coreclr/botr/exceptions.md index 9aa3556c8f6..370663852cf 100644 --- a/docs/design/coreclr/botr/exceptions.md +++ b/docs/design/coreclr/botr/exceptions.md @@ -162,7 +162,7 @@ Throwing an Exception in the CLR is generally a matter of calling COMPlusThrow ( < args > ) -There are a number of overloads, but the idea is to pass the "kind" of the exception to COMPlusThrow. The list of "kinds" is generated by a set of macros operating on [rexcep.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/rexcep.h), and the various "kinds" are kAmbiguousMatchException, kApplicationException, and so forth. Additional arguments (for the overloads) specify resources and substitution text. Generally, the right "kind" is selected by looking for other code that reports a similar error. +There are a number of overloads, but the idea is to pass the "kind" of the exception to COMPlusThrow. The list of "kinds" is generated by a set of macros operating on [rexcep.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/rexcep.h), and the various "kinds" are kAmbiguousMatchException, kApplicationException, and so forth. Additional arguments (for the overloads) specify resources and substitution text. Generally, the right "kind" is selected by looking for other code that reports a similar error. There are some pre-defined convenience variations: diff --git a/docs/design/coreclr/botr/garbage-collection.md b/docs/design/coreclr/botr/garbage-collection.md index f912b2ae4d2..88325a99413 100644 --- a/docs/design/coreclr/botr/garbage-collection.md +++ b/docs/design/coreclr/botr/garbage-collection.md @@ -327,7 +327,7 @@ Given WKS GC with concurrent GC on (default case), the code flow for a backgroun Resources ========= -- [.NET CLR GC Implementation](https://raw.githubusercontent.com/dotnet/runtime/master/src/coreclr/src/gc/gc.cpp) +- [.NET CLR GC Implementation](https://raw.githubusercontent.com/dotnet/runtime/master/src/coreclr/gc/gc.cpp) - [The Garbage Collection Handbook: The Art of Automatic Memory Management](http://www.amazon.com/Garbage-Collection-Handbook-Management-Algorithms/dp/1420082795) - [Garbage collection (Wikipedia)](http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)) - [Pro .NET Memory Management](https://prodotnetmemory.com/) diff --git a/docs/design/coreclr/botr/guide-for-porting.md b/docs/design/coreclr/botr/guide-for-porting.md index 62c294881bd..fec15080c5a 100644 --- a/docs/design/coreclr/botr/guide-for-porting.md +++ b/docs/design/coreclr/botr/guide-for-porting.md @@ -228,7 +228,7 @@ Notable components very machine specific paths. 4. The unwinder. The unwinder is used to unwind stacks on non-Windows platforms. - It is located in https://github.com/dotnet/runtime/tree/master/src/coreclr/src/unwinder. + It is located in https://github.com/dotnet/runtime/tree/master/src/coreclr/unwinder. 4. System.Private.CoreLib/System.Reflection. There is little to no architecture specific work here that is necessary for bringup. Nice-to-have work involves @@ -267,12 +267,12 @@ there are also architecture specific components. 4. jitsupport.cpp - Depending on how the features of the CPU are exposed, there may need to be code to call OS apis to gather information about CPU features. -5. pal arch directory - https://github.com/dotnet/runtime/tree/master/src/coreclr/src/pal/src/arch +5. pal arch directory - https://github.com/dotnet/runtime/tree/master/src/coreclr/pal/src/arch This directory primarily contains assembly stubs for architecture specific handling of signals and exceptions. In addition to the PAL source code, there is a comprehensive set of PAL tests located -in https://github.com/dotnet/runtime/tree/master/src/coreclr/src/pal/tests. +in https://github.com/dotnet/runtime/tree/master/src/coreclr/pal/tests. CLR VM ------ diff --git a/docs/design/coreclr/botr/method-descriptor.md b/docs/design/coreclr/botr/method-descriptor.md index 453e850f1d7..e163a8ca31f 100644 --- a/docs/design/coreclr/botr/method-descriptor.md +++ b/docs/design/coreclr/botr/method-descriptor.md @@ -91,7 +91,7 @@ The slot is either in MethodTable or in MethodDesc itself. The location of the s The slot is stored in MethodTable for methods that require efficient lookup via slot index, e.g. virtual methods or methods on generic types. The MethodDesc contains the slot index to allow fast lookup of the entry point in this case. -Otherwise, the slot is part of the MethodDesc itself. This arrangement improves data locality and saves working set. Also, it is not even always possible to preallocate a slot in a MethodTable upfront for dynamically created MethodDescs, such as for methods added by Edit & Continue, instantiations of generic methods or [dynamic methods](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs). +Otherwise, the slot is part of the MethodDesc itself. This arrangement improves data locality and saves working set. Also, it is not even always possible to preallocate a slot in a MethodTable upfront for dynamically created MethodDescs, such as for methods added by Edit & Continue, instantiations of generic methods or [dynamic methods](https://github.com/dotnet/runtime/blob/master/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs). MethodDesc Chunks ----------------- diff --git a/docs/design/coreclr/botr/profilability.md b/docs/design/coreclr/botr/profilability.md index 81aa394ed91..ed32066516c 100644 --- a/docs/design/coreclr/botr/profilability.md +++ b/docs/design/coreclr/botr/profilability.md @@ -225,14 +225,14 @@ It's pretty straightforward where to go, to add or modify methods, and code insp corprof.idl ----------- -All profiling API interfaces and types are defined in [src\inc\corprof.idl](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/corprof.idl). Go here first to define your types and methods. +All profiling API interfaces and types are defined in [src\inc\corprof.idl](https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/corprof.idl). Go here first to define your types and methods. EEToProfInterfaceImpl.\* ----------------------- -Wrapper around the profiler's implementation of ICorProfilerCallback is located at [src\vm\EEToProfInterfaceImpl.\*](https://github.com/dotnet/runtime/tree/master/src/coreclr/src/vm). +Wrapper around the profiler's implementation of ICorProfilerCallback is located at [src\vm\EEToProfInterfaceImpl.\*](https://github.com/dotnet/runtime/tree/master/src/coreclr/vm). ProfToEEInterfaceImpl.\* ----------------------- -Implementation of ICorProfilerInfo is located at [src\vm\ProfToEEInterfaceImpl.\*](https://github.com/dotnet/runtime/tree/master/src/coreclr/src/vm). +Implementation of ICorProfilerInfo is located at [src\vm\ProfToEEInterfaceImpl.\*](https://github.com/dotnet/runtime/tree/master/src/coreclr/vm). diff --git a/docs/design/coreclr/botr/readytorun-format.md b/docs/design/coreclr/botr/readytorun-format.md index ff48f53c16c..10f2193d495 100644 --- a/docs/design/coreclr/botr/readytorun-format.md +++ b/docs/design/coreclr/botr/readytorun-format.md @@ -58,7 +58,7 @@ The limitations of the current format are: # Structures The structures and accompanying constants are defined in the [readytorun.h] -(https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/readytorun.h) header file. +(https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/readytorun.h) header file. Basically the entire R2R executable image is addressed through the READYTORUN_HEADER singleton pointed to by the well-known export RTR_HEADER in the export section of the native executable envelope. @@ -281,7 +281,7 @@ additional data determined by the flags. ### READYTORUN_IMPORT_SECTIONS::AuxiliaryData For slots resolved lazily via `READYTORUN_HELPER_DelayLoad_MethodCall` helper, auxiliary data are -compressed argument maps that allow precise GC stack scanning while the helper is running. The CoreCLR runtime class [`GCRefMapDecoder`](https://github.com/dotnet/runtime/blob/8c6b1314c95857b9e2f5c222a10f2f089ee02dfe/src/coreclr/src/inc/gcrefmap.h#L157) is used to parse this information. This data would not be required for runtimes that allow conservative stack scanning. +compressed argument maps that allow precise GC stack scanning while the helper is running. The CoreCLR runtime class [`GCRefMapDecoder`](https://github.com/dotnet/runtime/blob/69e114c1abf91241a0eeecf1ecceab4711b8aa62/src/coreclr/inc/gcrefmap.h#L158) is used to parse this information. This data would not be required for runtimes that allow conservative stack scanning. The auxiliary data table contains the exact same number of GC ref map records as there are method entries in the import section. To accelerate GC ref map lookup, the auxiliary data section starts with a lookup table holding the offset of every 1024-th method in the runtime function table within the linearized GC ref map. @@ -294,7 +294,7 @@ The auxiliary data table contains the exact same number of GC ref map records as | 4 * (MethodCount / 1024 + 1) | ... | Serialized GC ref map info The GCRef map is used to encode GC type of arguments for callsites. Logically, it is a sequence `<pos, token>` where `pos` is -position of the reference in the stack frame and `token` is type of GC reference (one of [`GCREFMAP_XXX`](https://github.com/dotnet/runtime/blob/8c6b1314c95857b9e2f5c222a10f2f089ee02dfe/src/coreclr/src/inc/corcompile.h#L627) values): +position of the reference in the stack frame and `token` is type of GC reference (one of [`GCREFMAP_XXX`](https://github.com/dotnet/runtime/blob/69e114c1abf91241a0eeecf1ecceab4711b8aa62/src/coreclr/inc/corcompile.h#L633) values): | CORCOMPILE_GCREFMAP_TOKENS | Value | Stack frame entry interpretation |:---------------------------|------:|:-------------------------------- @@ -440,7 +440,7 @@ This section contains a native hashtable of all defined & export types within th | 1 | exported type The version-resilient hashing algorithm used for hashing the type names is implemented in -[vm/versionresilienthashcode.cpp](https://github.com/dotnet/runtime/blob/8c6b1314c95857b9e2f5c222a10f2f089ee02dfe/src/coreclr/src/vm/versionresilienthashcode.cpp#L75). +[vm/versionresilienthashcode.cpp](https://github.com/dotnet/runtime/blob/69e114c1abf91241a0eeecf1ecceab4711b8aa62/src/coreclr/vm/versionresilienthashcode.cpp#L74). **Note:** This is a per-assembly section. In single-file R2R files, it is pointed to directly by the main R2R header; in composite R2R files, each component module has its own available type section pointed to @@ -451,7 +451,7 @@ by the `READYTORUN_SECTION_ASSEMBLIES_ENTRY` core header structure. This section contains a native hashtable of all generic method instantiations compiled into the R2R executable. The key is the method instance signature; the appropriate version-resilient hash code calculation is implemented in -[vm/versionresilienthashcode.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/versionresilienthashcode.cpp#L127); +[vm/versionresilienthashcode.cpp](https://github.com/dotnet/runtime/blob/69e114c1abf91241a0eeecf1ecceab4711b8aa62/src/coreclr/vm/versionresilienthashcode.cpp#L126); the value, represented by the `EntryPointWithBlobVertex` class, stores the method index in the runtime function table, the fixups blob and a blob encoding the method signature. diff --git a/docs/design/coreclr/botr/shared-generics.md b/docs/design/coreclr/botr/shared-generics.md index 367d2caa6d8..0689b0d891d 100644 --- a/docs/design/coreclr/botr/shared-generics.md +++ b/docs/design/coreclr/botr/shared-generics.md @@ -111,7 +111,7 @@ When loading information from a slot that is still NULL, the generic code will c - `JIT_GenericHandleClass`: Used to lookup a value in a generic type dictionary. This helper is used by all instance methods on generic types. - `JIT_GenericHandleMethod`: Used to lookup a value in a generic method dictionary. This helper used by all generic methods, or non-generic static methods on generic types. -When generating shared generic code, the JIT knows which slots to use for the various lookups, and the kind of information contained in each slot using the help of the `DictionaryLayout` implementation ([genericdict.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/genericdict.cpp)). +When generating shared generic code, the JIT knows which slots to use for the various lookups, and the kind of information contained in each slot using the help of the `DictionaryLayout` implementation ([genericdict.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/genericdict.cpp)). ### Dictionary Layouts @@ -165,7 +165,7 @@ The feature is simple in concept: change dictionary layouts from a linked list o The current implementation expands the dictionary layout and the actual dictionaries separately to keep things simple: - - Dictionary layouts are expanded when we are out of empty slots. See implementations of `DictionaryLayout::FindToken()` in [genericdict.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/genericdict.cpp). + - Dictionary layouts are expanded when we are out of empty slots. See implementations of `DictionaryLayout::FindToken()` in [genericdict.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/genericdict.cpp). - Instantiated type and method dictionaries are expanded lazily on demand whenever any code is attempting to read the value of a slot beyond the size of the dictionary of that type or method. This is done through a call to the helper functions mentioned previously (`JIT_GenericHandleClass` and `JIT_GenericHandleMethod`). The dictionary access codegen is equivalent to the following (both in JITted code and ReadyToRun code): @@ -184,7 +184,7 @@ else This size check is **not** done unconditionally every time we need to read a value from the dictionary, otherwise this would cause a noticeable performance regression. When a dictionary layout is first allocated, we keep track of the initial number of slots that were allocated, and **only** perform the size checks if we are attempting to read the value of a slot beyond those initial number of slots. -Dictionaries on types and methods are expanded by the `Dictionary::GetTypeDictionaryWithSizeCheck()` and `Dictionary::GetMethodDictionaryWithSizeCheck()` helper functions in [genericdict.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/genericdict.cpp). +Dictionaries on types and methods are expanded by the `Dictionary::GetTypeDictionaryWithSizeCheck()` and `Dictionary::GetMethodDictionaryWithSizeCheck()` helper functions in [genericdict.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/genericdict.cpp). One thing to note regarding types is that they can inherit dictionary pointers from their base types. This means that if we resize the generic dictionary on any given generic type, we will need to propagate the new dictionary pointer to all of its derived types. This propagation is also done in a lazy way whenever the code calls into the `JIT_GenericHandleWorker` helper function with a derived type MethodTable pointer. In that helper, if we find that the dictionary pointer on the base type has been updated, we copy it to the derived type. diff --git a/docs/design/coreclr/botr/stackwalking.md b/docs/design/coreclr/botr/stackwalking.md index 75b4d4b8120..34870a04940 100644 --- a/docs/design/coreclr/botr/stackwalking.md +++ b/docs/design/coreclr/botr/stackwalking.md @@ -62,7 +62,7 @@ Essentially the stack walker, having decoded the current frame, always has two p When managed code calls into the unmanaged runtime one of several forms of transition Frame is often pushed by the unmanaged target method. This is needed both to record the register state of the calling managed method (so that the stack walker can resume virtual unwinding of managed frames once it has finished enumerating the unmanaged Frames) and in many cases because managed object references are passed as arguments to the unmanaged method and must be reported to the GC in the event of a garbage collection. -A full description of the available Frame types and their uses is beyond the scope of the document. Further details can be found in the [frames.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/frames.h) header file. +A full description of the available Frame types and their uses is beyond the scope of the document. Further details can be found in the [frames.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/frames.h) header file. # Stackwalker Interface @@ -72,11 +72,11 @@ The caller of this method provides three main inputs: 1. Some context indicating the starting point of the walk. This is either an initial register set (for instance if you've suspended the target thread and can call GetThreadContext() on it) or an initial Frame (in cases where you know the code in question is in runtime unmanaged code). Although most stack walks are made from the top of the stack it's possible to start lower down if you can determine the correct starting context. 2. A function pointer and associated context. The function provided is called by the stack walker for each interesting frame (in order from the newest to the oldest). The context value provided is passed to each invocation of the callback so that it can record or build up state during the walk. -3. Flags indicating what sort of frames should trigger a callback. This allows the caller to specify that only pure managed method frames should be reported for instance. For a full list see [threads.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/threads.h) (just above the declaration of StackWalkFramesEx()). +3. Flags indicating what sort of frames should trigger a callback. This allows the caller to specify that only pure managed method frames should be reported for instance. For a full list see [threads.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/threads.h) (just above the declaration of StackWalkFramesEx()). StackWalkFramesEx() returns an enum value that indicates whether the walk terminated normally (got to the stack base and ran out of methods to report), was aborted by one of the callbacks (the callbacks return an enum of the same type to the stack walk to control this) or suffered some other miscellaneous error. -Aside from the context value passed to StackWalkFramesEx(), stack callback functions are passed one other piece of context: the CrawlFrame. This class is defined in [stackwalk.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/stackwalk.h) and contains all sorts of context gathered as the stack walk proceeds. +Aside from the context value passed to StackWalkFramesEx(), stack callback functions are passed one other piece of context: the CrawlFrame. This class is defined in [stackwalk.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/stackwalk.h) and contains all sorts of context gathered as the stack walk proceeds. For instance the CrawlFrame indicates the MethodDesc* for managed frames and the Frame* for unmanaged Frames. It also provides the current register set inferred by virtually unwinding frames up to that point. diff --git a/docs/design/coreclr/botr/threading.md b/docs/design/coreclr/botr/threading.md index d6150209e38..cc5d0b16a78 100644 --- a/docs/design/coreclr/botr/threading.md +++ b/docs/design/coreclr/botr/threading.md @@ -27,7 +27,7 @@ Every managed thread has an associated Thread object, defined in [threads.h][thr All Thread objects are stored in the ThreadStore (also defined in [threads.h][threads.h]), which is a simple list of all known Thread objects. To enumerate all managed threads, one must first acquire the ThreadStoreLock, then use ThreadStore::GetAllThreadList to enumerate all Thread objects. This list may include managed threads which are not currently assigned to native threads (for example, they may not yet be started, or the native thread may already have exited). -[threads.h]: ../../../../src/coreclr/src/vm/threads.h +[threads.h]: ../../../../src/coreclr/vm/threads.h Each managed thread that is currently assigned to a native thread is reachable via a native thread-local storage (TLS) slot on that native thread. This allows code that is executing on that native thread to get the corresponding Thread object, via GetThread(). @@ -135,8 +135,8 @@ Sync blocks are stored in the Sync Block Table, and are addressed by sync block The details of object headers and sync blocks are defined in [syncblk.h][syncblk.h]/[.cpp][syncblk.cpp]. -[syncblk.h]: ../../../../src/coreclr/src/vm/syncblk.h -[syncblk.cpp]: ../../../../src/coreclr/src/vm/syncblk.cpp +[syncblk.h]: ../../../../src/coreclr/vm/syncblk.h +[syncblk.cpp]: ../../../../src/coreclr/vm/syncblk.cpp If there is room on the object header, Monitor stores the managed thread ID of the thread that currently holds the lock on the object (or zero (0) if no thread holds the lock). Acquiring the lock in this case is a simple matter of spin-waiting until the object header's thread ID is zero, and then atomically setting it to the current thread's managed thread ID. diff --git a/docs/design/coreclr/botr/type-loader.md b/docs/design/coreclr/botr/type-loader.md index d60676e3bcb..b193c3f15a2 100644 --- a/docs/design/coreclr/botr/type-loader.md +++ b/docs/design/coreclr/botr/type-loader.md @@ -166,7 +166,7 @@ These are valid types and apparently `A` depends on `B` and `B` depends on `A`. The loader initially creates the structure(s) representing the type and initializes them with data that can be obtained without loading other types. When this "no-dependencies" work is done, the structure(s) can be referred from other places, usually by sticking pointers to them into another structures. After that the loader progresses in incremental steps and fills the structure(s) with more and more information until it finally arrives at a fully loaded type. In the above example, the base types of `A` and `B` will be approximated by something that does not include the other type, and substituted by the real thing later. -The exact half-loaded state is described by the so-called load level, starting with CLASS\_LOAD\_BEGIN, ending with CLASS\_LOADED, and having a couple of intermediate levels in between. There are rich and useful comments about individual load levels in the [classloadlevel.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/classloadlevel.h) source file. Notice that although types can be saved in NGEN images, the representing structures cannot be simply mapped or blitted into memory and used without additional work called "restoring". The fact that a type came from an NGEN image and needs to be restored is also captured by its load level. +The exact half-loaded state is described by the so-called load level, starting with CLASS\_LOAD\_BEGIN, ending with CLASS\_LOADED, and having a couple of intermediate levels in between. There are rich and useful comments about individual load levels in the [classloadlevel.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/classloadlevel.h) source file. Notice that although types can be saved in NGEN images, the representing structures cannot be simply mapped or blitted into memory and used without additional work called "restoring". The fact that a type came from an NGEN image and needs to be restored is also captured by its load level. See [Design and Implementation of Generics for the .NET Common Language diff --git a/docs/design/coreclr/botr/virtual-stub-dispatch.md b/docs/design/coreclr/botr/virtual-stub-dispatch.md index bf67c5895bc..43f4f10a080 100644 --- a/docs/design/coreclr/botr/virtual-stub-dispatch.md +++ b/docs/design/coreclr/botr/virtual-stub-dispatch.md @@ -183,6 +183,6 @@ As a result of disabling VSD for virtual instance method calls, every type has a Physical Architecture ===================== -For dispatch token and map implementation details, please see [clr/src/vm/contractImpl.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/contractimpl.h) and [clr/src/vm/contractImpl.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/contractimpl.cpp). +For dispatch token and map implementation details, please see [clr/src/vm/contractImpl.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/contractimpl.h) and [clr/src/vm/contractImpl.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/contractimpl.cpp). -For virtual stub dispatch implementation details, please see [clr/src/vm/virtualcallstub.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/virtualcallstub.h) and [clr/src/vm/virtualcallstub.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/virtualcallstub.cpp). +For virtual stub dispatch implementation details, please see [clr/src/vm/virtualcallstub.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/virtualcallstub.h) and [clr/src/vm/virtualcallstub.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/virtualcallstub.cpp). diff --git a/docs/design/coreclr/botr/xplat-minidump-generation.md b/docs/design/coreclr/botr/xplat-minidump-generation.md index 46fd6bdf372..2e871f5f484 100644 --- a/docs/design/coreclr/botr/xplat-minidump-generation.md +++ b/docs/design/coreclr/botr/xplat-minidump-generation.md @@ -12,7 +12,7 @@ Our solution at this time is to intercept any unhandled exception in the PAL lay We looked at the existing technologies like Breakpad and its derivatives (e.g.: an internal MS version called _msbreakpad_ from the SQL team....). Breakpad generates Windows minidumps but they are not compatible with existing tools like Windbg, etc. Msbreakpad even more so. There is a minidump to Linux core conversion utility but it seems like a wasted extra step. _Breakpad_ does allow the minidump to be generated in-process inside the signal handlers. It restricts the APIs to what was allowed in a "async" signal handler (like SIGSEGV) and has a small subset of the C++ runtime that was also similarly constrained. We also need to add the set of memory regions for the "managed" state which requires loading and using the _DAC_'s (*) enumerate memory interfaces. Loading modules is not allowed in an async signal handler but forking/execve is allowed so launching an utility that loads the _DAC_, enumerates the list of memory regions and writes the dump is the only reasonable option. It would also allow uploading the dump to a server too. -\* The _DAC_ is a special build of parts of the coreclr runtime that allows inspection of the runtime's managed state (stacks, variables, GC state heaps) out of context. One of the many interfaces it provides is [ICLRDataEnumMemoryRegions](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/debug/daccess/dacimpl.h) which enumerates all the managed state a minidump would require to enable a fruitful debugging experience. +\* The _DAC_ is a special build of parts of the coreclr runtime that allows inspection of the runtime's managed state (stacks, variables, GC state heaps) out of context. One of the many interfaces it provides is [ICLRDataEnumMemoryRegions](https://github.com/dotnet/runtime/blob/master/src/coreclr/debug/daccess/dacimpl.h) which enumerates all the managed state a minidump would require to enable a fruitful debugging experience. _Breakpad_ could have still been used out of context in the generation utility but there seemed no value to their Windows-like minidump format when it would have to be converted to the native Linux core format away because in most scenarios using the platform tools like _lldb_ is necessary. It also adds a coreclr build dependency on Google's _Breakpad_ or SQL's _msbreakpad_ source repo. The only advantage is that the breakpad minidumps may be a little smaller because minidumps memory regions are byte granule and Linux core memory regions need to be page granule. @@ -20,7 +20,7 @@ _Breakpad_ could have still been used out of context in the generation utility b ### Linux ### -Core dump generation is triggered anytime coreclr is going to abort (via [PROCAbort()](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/src/include/pal/process.h)) the process because of an unhandled managed exception or an async signal like SIGSEGV, SIGILL, SIGFPE, etc. The _createdump_ utility is located in the same directory as libcoreclr.so and is launched with fork/execve. The child _createdump_ process is given permission to ptrace and access to the various special /proc files of the crashing process which waits until _createdump_ finishes. +Core dump generation is triggered anytime coreclr is going to abort (via [PROCAbort()](https://github.com/dotnet/runtime/blob/master/src/coreclr/pal/src/include/pal/process.h)) the process because of an unhandled managed exception or an async signal like SIGSEGV, SIGILL, SIGFPE, etc. The _createdump_ utility is located in the same directory as libcoreclr.so and is launched with fork/execve. The child _createdump_ process is given permission to ptrace and access to the various special /proc files of the crashing process which waits until _createdump_ finishes. The _createdump_ utility starts by using ptrace to enumerate and suspend all the threads in the target process. The process and thread info (status, registers, etc.) is gathered. The auxv entries and _DSO_ info is enumerated. _DSO_ is the in memory data structures that described the shared modules loaded by the target. This memory is needed in the dump by gdb and lldb to enumerate the shared modules loaded and access their symbols. The module memory mappings are gathered from /proc/$pid/maps. None of the program or shared modules memory regions are explicitly added to dump's memory regions. The _DAC_ is loaded and the enumerate memory region interfaces are used to build the memory regions list just like on Windows. The threads stacks and one page of code around the IP are added. The byte sized regions are rounded up to pages and then combined into contiguous regions. diff --git a/docs/design/coreclr/jit/ryujit-overview.md b/docs/design/coreclr/jit/ryujit-overview.md index 73cc095e065..110fa5cbe18 100644 --- a/docs/design/coreclr/jit/ryujit-overview.md +++ b/docs/design/coreclr/jit/ryujit-overview.md @@ -25,9 +25,9 @@ Depending upon the configuration, the EE and JIT may reside in the same or diffe implements the JIT side of the JIT/EE interfaces: * `ICorJitCompiler` – this is the interface that the JIT compiler implements. This interface is defined in -[src/inc/corjit.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/corjit.h) +[src/inc/corjit.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/corjit.h) and its implementation is in -[src/jit/ee_il_dll.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/ee_il_dll.cpp). +[src/jit/ee_il_dll.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/ee_il_dll.cpp). The following are the key methods on this interface: * `compileMethod` is the main entry point for the JIT. The EE passes it a `ICorJitInfo` object, and the "info" containing the IL, the method header, and various other useful tidbits. @@ -38,9 +38,9 @@ The following are the key methods on this interface: * `ICorJitInfo` – this is the interface that the EE implements. It has many methods defined on it that allow the JIT to look up metadata tokens, traverse type signatures, compute field and vtable offsets, find method entry points, construct string literals, etc. This bulk of this interface is inherited from `ICorDynamicInfo` which is defined in -[src/inc/corinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/corinfo.h). The implementation +[src/inc/corinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/corinfo.h). The implementation is defined in -[src/vm/jitinterface.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/jitinterface.cpp). +[src/vm/jitinterface.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/jitinterface.cpp). # Internal Representation (IR) @@ -698,11 +698,11 @@ at points where accurate counts are valuable. Currently this happens before and ## Instruction encoding Instruction encoding is performed by the emitter -([emit.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/emit.h)), using the +([emit.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/emit.h)), using the `insGroup`/`instrDesc` representation. The code generator calls methods on the emitter to construct `instrDescs`. The encodings information is captured in the following: -* The "instruction" enumeration itemizes the different instructions available on each target, and is used as an index into the various encoding tables (e.g. `instInfo[]`, `emitInsModeFmtTab[]`) generated from the `instrs{tgt}.h` (e.g., [instrsxarch.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/instrsxarch.h)). +* The "instruction" enumeration itemizes the different instructions available on each target, and is used as an index into the various encoding tables (e.g. `instInfo[]`, `emitInsModeFmtTab[]`) generated from the `instrs{tgt}.h` (e.g., [instrsxarch.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/instrsxarch.h)). * The skeleton encodings are contained in the tables, and then there are methods on the emitter that handle the special encoding constraints for the various instructions, addressing modes, register types, etc. ## GC Info @@ -713,10 +713,10 @@ Reporting of live GC references is done in two ways: * For lclVars with tracked lifetimes, or for expression involving GC references, we report the range over which the reference is live. This is done by the emitter, which adds this information to the instruction group, and which terminates instruction groups when the GC info changes. The tracking of GC reference lifetimes is done via the `GCInfo` class in the JIT. It is declared in -[src/jit/jitgcinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/jitgcinfo.h) (to +[src/jit/jitgcinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/jitgcinfo.h) (to differentiate it from -[src/inc/gcinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/inc/gcinfo.h)), and implemented in -[src/jit/gcinfo.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/gcinfo.cpp). +[src/inc/gcinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/inc/gcinfo.h)), and implemented in +[src/jit/gcinfo.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/gcinfo.cpp). In a JitDump, the generated GC info can be seen following the "In gcInfoBlockHdrSave()" line. @@ -729,15 +729,15 @@ Debug info consists primarily of two types of information in the JIT: * the `gtLclILoffs` on lclVar references (`GenTreeLclVar`) * The IL offsets are captured during CodeGen by calling `CodeGen::genIPmappingAdd()`, and then written to debug tables by `CodeGen::genIPmappingGen()`. * Mapping of user locals to location (register or stack). This is accomplished via: - * Struct `siVarLoc` (in [compiler.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/compiler.h)) captures the location - * `VarScopeDsc` ([compiler.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/compiler.h)) captures the live range of a local variable in a given location. + * Struct `siVarLoc` (in [compiler.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/compiler.h)) captures the location + * `VarScopeDsc` ([compiler.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/compiler.h)) captures the live range of a local variable in a given location. ## Exception handling Exception handling information is captured in an `EHblkDsc` for each exception handling region. Each region includes the first and last blocks of the try and handler regions, exception type, enclosing region, among other things. Look -at [jiteh.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/jiteh.h) and -[jiteh.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/jiteh.cpp), especially, for details. +at [jiteh.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/jiteh.h) and +[jiteh.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/jiteh.cpp), especially, for details. Look at `Compiler::fgVerifyHandlerTab()` to see how the exception table constraints are verified. # Reading a JitDump @@ -838,7 +838,7 @@ STMT00000 (IL 0x010... ???) Tree nodes are identified by their `gtTreeID`. This field only exists in DEBUG builds, but is quite useful for debugging, since all tree nodes are created from the routine `gtNewNode` (in -[src/jit/gentree.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/gentree.cpp)). If you find a +[src/jit/gentree.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/gentree.cpp)). If you find a bad tree and wish to understand how it got corrupted, you can place a conditional breakpoint at the end of `gtNewNode` to see when it is created, and then a data breakpoint on the field that you believe is corrupted. diff --git a/docs/design/coreclr/jit/ryujit-tutorial.md b/docs/design/coreclr/jit/ryujit-tutorial.md index 69e90580fbf..d402f6b948a 100644 --- a/docs/design/coreclr/jit/ryujit-tutorial.md +++ b/docs/design/coreclr/jit/ryujit-tutorial.md @@ -6,7 +6,7 @@ - An implementation of the Common Language Infrastructure [ECMA 335] - Supports multiple languages, including C#, F# and VB - RyuJIT is the "next generation" just in time compiler for .NET -- Sources are at https://github.com/dotnet/runtime/tree/master/src/coreclr/src/jit +- Sources are at https://github.com/dotnet/runtime/tree/master/src/coreclr/jit #### Notes For context, the .NET runtime has been around since about the turn of the millennium. It is a virtual machine that supports the execution of a number of languages, primarily C#, Visual Basic, and F#. diff --git a/docs/design/coreclr/jit/viewing-jit-dumps.md b/docs/design/coreclr/jit/viewing-jit-dumps.md index 8e282e0166b..41cc479d411 100644 --- a/docs/design/coreclr/jit/viewing-jit-dumps.md +++ b/docs/design/coreclr/jit/viewing-jit-dumps.md @@ -98,7 +98,7 @@ The first thing to do is setup the .NET Core app we want to dump. Here are the s ## Setting configuration variables -The behavior of the JIT can be controlled via a number of configuration variables. These are declared in [inc/clrconfigvalues.h](/src/coreclr/src/inc/clrconfigvalues.h) and [jit/jitconfigvalues.h](/src/coreclr/src/jit/jitconfigvalues.h). When used as an environment variable, the string name generally has `COMPlus_` prepended. When used as a registry value name, the configuration name is used directly. +The behavior of the JIT can be controlled via a number of configuration variables. These are declared in [inc/clrconfigvalues.h](/src/coreclr/inc/clrconfigvalues.h) and [jit/jitconfigvalues.h](/src/coreclr/jit/jitconfigvalues.h). When used as an environment variable, the string name generally has `COMPlus_` prepended. When used as a registry value name, the configuration name is used directly. These can be set in one of three ways: diff --git a/docs/design/features/DynamicPgo.md b/docs/design/features/DynamicPgo.md index b29f165ddd5..d74307aa9a1 100644 --- a/docs/design/features/DynamicPgo.md +++ b/docs/design/features/DynamicPgo.md @@ -144,7 +144,7 @@ The implementation for TieredPGO was intentionally kept simple (in part to allow If we want to externalize data for offline analysis or to feed into a subsequent run of the program, we also need to produce some keying data so that the per-method data can be matched up properly later on. -This is surprisingly challenging in .NET as there's not a strong external notion of method identity from one run to the next. We currently rely on token, hash, and il size as keys. Note things like the multi-core JIT must solve similar problems. We will leverage David Wrighton's [dotnet-pgo](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/tools/dotnet-pgo/dotnet-pgo-experiment.md) work here. +This is surprisingly challenging in .NET as there's not a strong external notion of method identity from one run to the next. We currently rely on token, hash, and il size as keys. Note things like the multi-core JIT must solve similar problems. We will leverage David Wrighton's [dotnet-pgo](https://github.com/dotnet/runtime/blob/master/src/coreclr/tools/dotnet-pgo/dotnet-pgo-experiment.md) work here. We may also wish to externalize flow graphs to allow offline analysis or to allow some kind of fuzzy matching of old profile data in a new version of the program (this is done by MSVC for example). diff --git a/docs/design/features/code-versioning.md b/docs/design/features/code-versioning.md index aa75023a839..800a77b9951 100644 --- a/docs/design/features/code-versioning.md +++ b/docs/design/features/code-versioning.md @@ -158,7 +158,7 @@ Implementation ### Code Versions ### -The implementation can be located in [codeversion.h](../../../src/coreclr/src/vm/codeversion.h) and [codeversion.cpp](../../../src/coreclr/src/vm/codeversion.cpp) +The implementation can be located in [codeversion.h](../../../src/coreclr/vm/codeversion.h) and [codeversion.cpp](../../../src/coreclr/vm/codeversion.cpp) Code versions are embodied by the configuration in NativeCodeVersion structure as well as the configuration in the transitively reachable ILCodeVersion. NativeCodeVersion::GetILCodeVersion() allows trivial access from one part of the configuration to the other. These structures have various accesors to retrieve all the code and configuration data such as: @@ -327,7 +327,7 @@ to update the active child at either of those levels (ReJIT uses SetActiveILCode 2. Recalculate the active code version for each entrypoint 3. Update the published code version for each entrypoint to match the active code version -In order to do step 3 the `CodeVersionManager` relies on one of three different mechanisms, a `FixupPrecode`, a `JumpStamp`, or backpatching entry point slots. In [method.hpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/vm/method.hpp) these mechanisms are described in the `MethodDesc::IsVersionableWith*()` functions, and all methods have been classified to use at most one of the techniques, based on the `MethodDesc::IsVersionableWith*()` functions. +In order to do step 3 the `CodeVersionManager` relies on one of three different mechanisms, a `FixupPrecode`, a `JumpStamp`, or backpatching entry point slots. In [method.hpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/vm/method.hpp) these mechanisms are described in the `MethodDesc::IsVersionableWith*()` functions, and all methods have been classified to use at most one of the techniques, based on the `MethodDesc::IsVersionableWith*()` functions. ### Thread-safety ### CodeVersionManager is designed for use in a free-threaded environment, in many cases by requiring the caller to acquire a lock before calling. This lock can be acquired by constructing an instance of `CodeVersionManager::LockHolder`. diff --git a/docs/design/features/hw-intrinsics.md b/docs/design/features/hw-intrinsics.md index 5dba25eac13..70aec90f29e 100644 --- a/docs/design/features/hw-intrinsics.md +++ b/docs/design/features/hw-intrinsics.md @@ -12,7 +12,7 @@ There is a design document for the Arm64 intrinsics: https://github.com/dotnet/r The reference assemblies for the hardware intrinsics live in corefx, but all of the implementation is in the coreclr repo: -* The C# implementation lives in coreclr/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics. These are little more than skeleton methods that are only compiled if needed for indirect invocation. +* The C# implementation lives in coreclr/System.Private.CoreLib/shared/System/Runtime/Intrinsics. These are little more than skeleton methods that are only compiled if needed for indirect invocation. * Note that they are mirrored to other repositories, including corefx, corert and mono. @@ -53,7 +53,7 @@ The JIT depends on the VM and configuration settings to determine what target pl ### Importation -Hardware intrinsics are built on RyuJIT's `NamedIntrinsic` mechanism to identify method calls that should be recognized as intrinsics (see https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/namedintrinsiclist.h). In the incoming IL, intrinsic invocations are just method calls, so the JIT must distinguish intrinsic calls from ordinary call-sites and map them to its IR representation: the `GenTreeHWIntrinsic` node. +Hardware intrinsics are built on RyuJIT's `NamedIntrinsic` mechanism to identify method calls that should be recognized as intrinsics (see https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/namedintrinsiclist.h). In the incoming IL, intrinsic invocations are just method calls, so the JIT must distinguish intrinsic calls from ordinary call-sites and map them to its IR representation: the `GenTreeHWIntrinsic` node. The [Intrinsic] attribute was added to eliminate the need to check each call-site. It [Intrinsic] attribute has a different meaning on each attribute target: @@ -112,7 +112,7 @@ By design, the actual code generation is fairly straightforward, since the hardw The only thing that makes the hardware intrinsics different in the area of instruction encodings is that they depend on many instructions (and their encodings) that are not used in any context other than the implementation of the associated hardware intrinsic. -The encodings are largely specified by `coreclr\src\jit\instrs{arch}.h`, and most of the target-specific code is in the `emit{arch}.*` files. +The encodings are largely specified by `coreclr\jit\instrs{arch}.h`, and most of the target-specific code is in the `emit{arch}.*` files. This is an area of the JIT that could use some redesign and refactoring (https://github.com/dotnet/runtime/issues/12178 and https://github.com/dotnet/runtime/issues/11631 among others). diff --git a/docs/design/features/native-hosting.md b/docs/design/features/native-hosting.md index 92afe1b019a..38c61d8eecb 100644 --- a/docs/design/features/native-hosting.md +++ b/docs/design/features/native-hosting.md @@ -18,10 +18,10 @@ App (native or .NET Core both) which needs to use some of the other services pro ## Existing support * **C-style ABI in `coreclr`** -`coreclr` exposes ABI to host the .NET runtime and run managed code already using C-style APIs. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/hosts/inc/coreclrhost.h) for the exposed functions. +`coreclr` exposes ABI to host the .NET runtime and run managed code already using C-style APIs. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/hosts/inc/coreclrhost.h) for the exposed functions. This API requires the native host to locate the runtime and to fully specify all startup parameters for the runtime. There's no inherent interoperability between these APIs and the .NET SDK. * **COM-style ABI in `coreclr`** -`coreclr` exposes COM-style ABI to host the .NET runtime and perform a wide range of operations on it. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/prebuilt/inc/mscoree.h) for more details. +`coreclr` exposes COM-style ABI to host the .NET runtime and perform a wide range of operations on it. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/pal/prebuilt/inc/mscoree.h) for more details. Similarly to the C-style ABI the COM-style ABI also requires the native host to locate the runtime and to fully specify all startup parameters. There's no inherent interoperability between these APIs and the .NET SDK. The COM-style ABI is deprecated and should not be used going forward. diff --git a/docs/design/features/standalone-gc-eventing.md b/docs/design/features/standalone-gc-eventing.md index 7b1f9dd560d..899714883b6 100644 --- a/docs/design/features/standalone-gc-eventing.md +++ b/docs/design/features/standalone-gc-eventing.md @@ -186,7 +186,7 @@ Tools (specifically PerfView) will want to be enlightened about dynamic events f we want to make this experience nice is up to us, but we will most likely want to ship PerfView support for any dynamic event that we end up shipping with the CLR GC. -[1]: https://github.com/dotnet/runtime/blob/master/src/coreclr/src/gc/env/etmdummy.h#L5-L57 +[1]: https://github.com/dotnet/runtime/blob/master/src/coreclr/gc/env/etmdummy.h#L5-L57 ### Concrete Example: Porting a single known event to IGCToCLREventSink diff --git a/docs/design/features/standalone-gc-loading.md b/docs/design/features/standalone-gc-loading.md index 5a4ce9f7280..2bdc65f830d 100644 --- a/docs/design/features/standalone-gc-loading.md +++ b/docs/design/features/standalone-gc-loading.md @@ -47,7 +47,7 @@ Worth noting is that the JIT (both RyuJIT and the legacy JIT(s) before it) can b and have realized these same benefits. The existence of an interface and an implementation loadable from shared libraries has enabled RyuJIT in particular to be used as the code generator for both the CoreRT compiler and crossgen, while still being flexible enough to be tested using tools that implement -very non-standard execution engines such as [SuperPMI](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/ToolBox/superpmi/readme.txt). +very non-standard execution engines such as [SuperPMI](https://github.com/dotnet/runtime/blob/master/src/coreclr/ToolBox/superpmi/readme.txt). The below loading protocol is inspired directly by the JIT loader and many aspects of the GC loader are identical to what the JIT does when loading dynamic shared libraries. diff --git a/docs/design/features/tiered-compilation.md b/docs/design/features/tiered-compilation.md index caedd79f94f..dcade2e53cf 100644 --- a/docs/design/features/tiered-compilation.md +++ b/docs/design/features/tiered-compilation.md @@ -82,11 +82,11 @@ Despite the anticipated shortcomings, the 2.1 RTM policy is a surprisingly decen Implementation ============== -The majority of the implementation can be located in [tieredcompilation.h](../../../src/coreclr/src/vm/tieredcompilation.h), and [tieredcompilation.cpp](../../../src/coreclr/src/vm/tieredcompilation.cpp) +The majority of the implementation can be located in [tieredcompilation.h](../../../src/coreclr/vm/tieredcompilation.h), and [tieredcompilation.cpp](../../../src/coreclr/vm/tieredcompilation.cpp) -The call counter is implemented in [callcounter.h](../../../src/coreclr/src/vm/callcounter.h), and [callcounter.cpp](../../../src/coreclr/src/vm/callcounter.cpp) +The call counter is implemented in [callcounter.h](../../../src/coreclr/vm/callcounter.h), and [callcounter.cpp](../../../src/coreclr/vm/callcounter.cpp) -The policy that determines which methods are eligible for tiering is implemented in `MethodDesc::IsEligibleForTieredCompilation`, located in [method.hpp](../../../src/coreclr/src/vm/method.hpp) +The policy that determines which methods are eligible for tiering is implemented in `MethodDesc::IsEligibleForTieredCompilation`, located in [method.hpp](../../../src/coreclr/vm/method.hpp) Most of the implementation is relatively straightforward given the design and best described by reading the code, but a few notes: diff --git a/docs/project/glossary.md b/docs/project/glossary.md index b36f0eaf4cd..54adf55a3f3 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -24,7 +24,7 @@ terminology. | GC | [Garbage Collector](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/garbage-collection.md). | | IPC | Inter-Process Communication. | | JIT | [Just-in-Time](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/jit/ryujit-overview.md) compiler. RyuJIT is the code name for the next generation Just-in-Time(aka "JIT") for the .NET runtime. | -| LCG | Lightweight Code Generation. An early name for [dynamic methods](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs). | +| LCG | Lightweight Code Generation. An early name for [dynamic methods](https://github.com/dotnet/runtime/blob/master/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs). | | MD | MetaData. | | MDA | Managed Debugging Assistant - see [details](https://docs.microsoft.com/en-us/dotnet/framework/debug-trace-profile/diagnosing-errors-with-managed-debugging-assistants) (Note: Not in .NET Core, equivalent diagnostic functionality is made available on a case-by-case basis, e.g. [#9418](https://github.com/dotnet/runtime/issues/9418)) | | NGen | Native Image Generator. | @@ -37,7 +37,7 @@ terminology. | R2R | Ready-to-Run. A flavor of native images - command line switch of [crossgen](../workflow/building/coreclr/crossgen.md). | | Redhawk | Codename for experimental minimal managed code runtime that evolved into [CoreRT](https://github.com/dotnet/corert/). | | SOS | [Son of Strike](https://docs.microsoft.com/en-us/archive/blogs/jasonz/sos-debugging-of-the-clr-part-1). The debugging extension for DbgEng based debuggers. Uses the DAC as an abstraction layer for its operation. | -| SuperPMI | JIT component test framework (super fast JIT testing - it mocks/replays EE in EE-JIT interface) - see [SuperPMI details](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/ToolBox/superpmi/readme.txt). | +| SuperPMI | JIT component test framework (super fast JIT testing - it mocks/replays EE in EE-JIT interface) - see [SuperPMI details](https://github.com/dotnet/runtime/blob/master/src/coreclr/ToolBox/superpmi/readme.txt). | | SVR | The CLR used to be built as two variants, with one called "mscorsvr.dll", to mean the "server" version. In particular, it contained the server GC implementation, which was intended for multi-threaded apps capable of taking advantage of multiple processors. In the .NET Framework 2 release, the two variants were merged into "mscorwks.dll". The WKS version was the default, however the SVR version remained available. | | TPA | Trusted Platform Assemblies used to be a special set of assemblies that comprised the platform assemblies, when it was originally designed. As of today, it is simply the set of assemblies known to constitute the application. | | URT | Universal Runtime. Ancient name for what ended up being .NET, is used in the WinError facility name FACILITY_URT. | diff --git a/docs/project/updating-jitinterface.md b/docs/project/updating-jitinterface.md index d5304124d1e..b3750e533c5 100644 --- a/docs/project/updating-jitinterface.md +++ b/docs/project/updating-jitinterface.md @@ -12,7 +12,7 @@ There are several components that consume the JIT outside of the runtime. Since The JitInterface is versioned by a GUID. Any change to JitInterface is required to update the JitInterface GUID located in jiteeversionguid.h (look for `JITEEVersionIdentifier`). Not doing so has consequences that are sometimes hard to debug. -If a method was added or modified in ICorStaticInfo or ICorDynamicInfo, port the change to src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt. Functions must be in the same order in ThunkInput.txt as they exist in corinfo.h and corjit.h. Run gen.bat or gen.sh to regenerate CorInfoBase.cs, jitinterface.h, ICorJitInfo_API_names.h, ICorJitInfo_API_wrapper.hpp, superpmi-shared\icorjitinfoimpl.h, superpmi-shim-counter\icorjitinfo.cpp, and superpmi-shim-simple\icorjitinfo.cpp from ThunkInput.txt. Provide a managed implementation of the method in CorInfoImpl.cs. +If a method was added or modified in ICorStaticInfo or ICorDynamicInfo, port the change to src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt. Functions must be in the same order in ThunkInput.txt as they exist in corinfo.h and corjit.h. Run gen.bat or gen.sh to regenerate CorInfoBase.cs, jitinterface.h, ICorJitInfo_API_names.h, ICorJitInfo_API_wrapper.hpp, superpmi-shared\icorjitinfoimpl.h, superpmi-shim-counter\icorjitinfo.cpp, and superpmi-shim-simple\icorjitinfo.cpp from ThunkInput.txt. Provide a managed implementation of the method in CorInfoImpl.cs. ## Porting JitInterface changes to crossgen2 diff --git a/docs/workflow/building/coreclr/android.md b/docs/workflow/building/coreclr/android.md index 74a2d19ecd4..4b785ccad31 100644 --- a/docs/workflow/building/coreclr/android.md +++ b/docs/workflow/building/coreclr/android.md @@ -42,7 +42,7 @@ You can run the PAL tests on an Android device. To run the tests, you first copy To copy the PAL tests over to an Android phone: ``` -adb push artifacts/obj/coreclr/Linux.arm64.Debug/src/pal/tests/palsuite/ /data/local/tmp/coreclr/src/pal/tests/palsuite +adb push artifacts/obj/coreclr/Linux.arm64.Debug/src/pal/tests/palsuite/ /data/local/tmp/coreclr/pal/tests/palsuite adb push cross/android/toolchain/arm64/sysroot/usr/lib/libandroid-support.so /data/local/tmp/coreclr/lib/ adb push cross/android/toolchain/arm64/sysroot/usr/lib/libandroid-glob.so /data/local/tmp/coreclr/lib/ adb push src/pal/tests/palsuite/paltestlist.txt /data/local/tmp/coreclr diff --git a/docs/workflow/ci/coreclr-ci-health.md b/docs/workflow/ci/coreclr-ci-health.md index 935b6c9087f..b48f52cd841 100644 --- a/docs/workflow/ci/coreclr-ci-health.md +++ b/docs/workflow/ci/coreclr-ci-health.md @@ -42,7 +42,7 @@ a "Shared" comment it signifies that our tests are built on OSX in ~15 minutes i *Special Jobs* -`Formatting Linux x64` and `Formatting Windows x64` are special jobs which run clang-tidy of `src/coreclr/src/jit/*`. If there is a failure, there is a patch file that is created that can be applied to fix the source formatting. +`Formatting Linux x64` and `Formatting Windows x64` are special jobs which run clang-tidy of `src/coreclr/jit/*`. If there is a failure, there is a patch file that is created that can be applied to fix the source formatting. | OS | Architecture | Build Type | Product Build | Build Tests | Run coreclr Tests | Test Count | R2R | | -- | ------------ | ---------- | ------------- | ----------- | ----------------- | ---------- | ----- | diff --git a/docs/workflow/editing-and-debugging.md b/docs/workflow/editing-and-debugging.md index 5ffc9813b9c..50213150e4b 100644 --- a/docs/workflow/editing-and-debugging.md +++ b/docs/workflow/editing-and-debugging.md @@ -17,7 +17,7 @@ more on Markdown in general. The repository has a number of Visual Studio Solutions files (`*.sln`) that are useful for editing parts of the repository. In particular - * `src\coreclr\src\System.Private.CoreLib\System.Private.CorLib.sln` - This solution is for all managed (C#) code that is defined + * `src\coreclr\System.Private.CoreLib\System.Private.CorLib.sln` - This solution is for all managed (C#) code that is defined in the runtime itself. This is all class library support of one form or another. * `artifacts\obj\coreclr\windows.<Arch>.<BuildType>\CoreCLR.sln` - this solution contains most native (C++) projects associated with the repository, including diff --git a/docs/workflow/testing/coreclr/unix-test-instructions.md b/docs/workflow/testing/coreclr/unix-test-instructions.md index eeee6137909..c11a6943965 100644 --- a/docs/workflow/testing/coreclr/unix-test-instructions.md +++ b/docs/workflow/testing/coreclr/unix-test-instructions.md @@ -110,7 +110,7 @@ Run tests: To run all tests including disabled tests ```sh -./src/coreclr/src/pal/tests/palsuite/runpaltests.sh $(pwd)/artifacts/bin/coreclr/$(uname).x64.Debug/paltests +./src/coreclr/pal/tests/palsuite/runpaltests.sh $(pwd)/artifacts/bin/coreclr/$(uname).x64.Debug/paltests # on macOS, replace $(uname) with OSX ``` To only run enabled tests for the platform the tests were built for: @@ -122,4 +122,4 @@ artifacts/bin/coreclr/$(uname).x64.Debug/paltests/runpaltests.sh $(pwd)/artifact Test results will go into: `/tmp/PalTestOutput/default/pal_tests.xml` To disable tests in the CI edit -`src/coreclr/src/pal/tests/palsuite/issues.targets` +`src/coreclr/pal/tests/palsuite/issues.targets` diff --git a/eng/build.ps1 b/eng/build.ps1 index 4faea7ff30c..1edde94bd28 100644 --- a/eng/build.ps1 +++ b/eng/build.ps1 @@ -150,7 +150,7 @@ if ($vs) { $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\mono\netcore" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.sln" } else { # Search for the solution in coreclr - $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\coreclr\src" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.sln" + $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\coreclr" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.sln" } if (-Not (Test-Path $vs)) { diff --git a/eng/native/sanitizerblacklist.txt b/eng/native/sanitizerblacklist.txt index ec3313973bf..ecc8bef9bf6 100644 --- a/eng/native/sanitizerblacklist.txt +++ b/eng/native/sanitizerblacklist.txt @@ -8,7 +8,7 @@ fun:_ZN11CMiniMdBase19UsesAllocatedMemoryEP11CMiniColDef # 0 0x4e8a0c in __ubsan::checkDynamicType(void*, void*, unsigned long) # 1 0x4e807f in HandleDynamicTypeCacheMiss(__ubsan::DynamicTypeCacheMissData*, unsigned long, unsigned long, __ubsan::ReportOptions) # 2 0x4e8051 in __ubsan_handle_dynamic_type_cache_miss -# 3 0x7f02ce676cd8 in JIT_InitPInvokeFrame(InlinedCallFrame*, void*) /home/steveharter/git/dotnet_coreclr/src/vm/jithelpers.cpp:6491:9 +# 3 0x7f02ce676cd8 in JIT_InitPInvokeFrame(InlinedCallFrame*, void*) /home/steveharter/git/dotnet_coreclr/vm/jithelpers.cpp:6491:9 # 4 0x7f0252bbceb2 (<unknown module>) fun:_Z20JIT_InitPInvokeFrameP16InlinedCallFramePv diff --git a/eng/pipelines/coreclr/ilasm.yml b/eng/pipelines/coreclr/ilasm.yml index ebf13e90119..d7554c288bd 100644 --- a/eng/pipelines/coreclr/ilasm.yml +++ b/eng/pipelines/coreclr/ilasm.yml @@ -6,8 +6,8 @@ pr: - master paths: include: - - src/coreclr/src/ilasm/* - - src/coreclr/src/ildasm/* + - src/coreclr/ilasm/* + - src/coreclr/ildasm/* schedules: - cron: "0 19 * * 6" diff --git a/eng/pipelines/coreclr/jitrollingbuild.yml b/eng/pipelines/coreclr/jitrollingbuild.yml index 9d608216059..3055961a44c 100644 --- a/eng/pipelines/coreclr/jitrollingbuild.yml +++ b/eng/pipelines/coreclr/jitrollingbuild.yml @@ -5,7 +5,7 @@ trigger: - master paths: include: - - src/coreclr/src/jit/* + - src/coreclr/jit/* pr: none diff --git a/eng/pipelines/coreclr/superpmi.yml b/eng/pipelines/coreclr/superpmi.yml index e05d1cd3a9c..4cbb976f163 100644 --- a/eng/pipelines/coreclr/superpmi.yml +++ b/eng/pipelines/coreclr/superpmi.yml @@ -9,7 +9,7 @@ trigger: - master paths: include: - - src/coreclr/src/inc/jiteeversionguid.h + - src/coreclr/inc/jiteeversionguid.h pr: none diff --git a/src/coreclr/ToolBox/superpmi/readme.md b/src/coreclr/ToolBox/superpmi/readme.md index 9195711a1ea..d9aded28c47 100644 --- a/src/coreclr/ToolBox/superpmi/readme.md +++ b/src/coreclr/ToolBox/superpmi/readme.md @@ -1,6 +1,6 @@ # Overview -This directory (`src/coreclr/src/ToolBox/superpmi` in the GitHub +This directory (`src/coreclr/ToolBox/superpmi` in the GitHub https://github.com/dotnet/runtime repository) contains the SuperPMI tool used for testing the .NET just-in-time (JIT) compiler. diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/icorjitinfoimpl.h b/src/coreclr/ToolBox/superpmi/superpmi-shared/icorjitinfoimpl.h index 3089d361e20..9693846a6f3 100644 --- a/src/coreclr/ToolBox/superpmi/superpmi-shared/icorjitinfoimpl.h +++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/icorjitinfoimpl.h @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md #ifndef _ICorJitInfoImpl diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/icorjitinfo.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/icorjitinfo.cpp index 36a7e280cfa..bb32bdf36a3 100644 --- a/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/icorjitinfo.cpp +++ b/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/icorjitinfo.cpp @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md #include "standardpch.h" diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/icorjitinfo.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/icorjitinfo.cpp index de8ca59c548..64c3e0e9e85 100644 --- a/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/icorjitinfo.cpp +++ b/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/icorjitinfo.cpp @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md #include "standardpch.h" diff --git a/src/coreclr/gc/vxsort/smallsort/codegen/bitonic_gen.py b/src/coreclr/gc/vxsort/smallsort/codegen/bitonic_gen.py index 55ef7bbc0f4..7e488d85453 100644 --- a/src/coreclr/gc/vxsort/smallsort/codegen/bitonic_gen.py +++ b/src/coreclr/gc/vxsort/smallsort/codegen/bitonic_gen.py @@ -10,7 +10,7 @@ # usage: bitonic_gen.py [-h] [--vector-isa VECTOR_ISA [VECTOR_ISA ...]] # [--break-inline BREAK_INLINE] [--output-dir OUTPUT_DIR] # -# the files in src/coreclr/src/gc/vxsort/smallsort that are currently checked in can be generated with: +# the files in src/coreclr/gc/vxsort/smallsort that are currently checked in can be generated with: # python bitonic_gen.py --output-dir c:\temp --vector-isa AVX2 AVX512 --break-inline 4 # import argparse diff --git a/src/coreclr/inc/corinfoinstructionset.h b/src/coreclr/inc/corinfoinstructionset.h index c292403b9e1..75ab11d7aea 100644 --- a/src/coreclr/inc/corinfoinstructionset.h +++ b/src/coreclr/inc/corinfoinstructionset.h @@ -2,8 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat #ifndef CORINFOINSTRUCTIONSET_H #define CORINFOINSTRUCTIONSET_H diff --git a/src/coreclr/inc/crosscomp.h b/src/coreclr/inc/crosscomp.h index e942db59e4a..d5d8cc8bd70 100644 --- a/src/coreclr/inc/crosscomp.h +++ b/src/coreclr/inc/crosscomp.h @@ -399,7 +399,7 @@ enum #if defined(DACCESS_COMPILE) && defined(TARGET_UNIX) // This is a TARGET oriented copy of CRITICAL_SECTION and PAL_CS_NATIVE_DATA_SIZE // It is configured based on TARGET configuration rather than HOST configuration -// There is validation code in src/coreclr/src/vm/crst.cpp to keep these from +// There is validation code in src/coreclr/vm/crst.cpp to keep these from // getting out of sync #define T_CRITICAL_SECTION_VALIDATION_MESSAGE "T_CRITICAL_SECTION validation failed. It is not in sync with CRITICAL_SECTION" diff --git a/src/coreclr/inc/readytorun.h b/src/coreclr/inc/readytorun.h index 84d3a81a94a..5122aa52610 100644 --- a/src/coreclr/inc/readytorun.h +++ b/src/coreclr/inc/readytorun.h @@ -14,7 +14,7 @@ #define READYTORUN_SIGNATURE 0x00525452 // 'RTR' -// Keep these in sync with src/coreclr/src/tools/Common/Internal/Runtime/ModuleHeaders.cs +// Keep these in sync with src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs #define READYTORUN_MAJOR_VERSION 0x0004 #define READYTORUN_MINOR_VERSION 0x0002 diff --git a/src/coreclr/inc/readytoruninstructionset.h b/src/coreclr/inc/readytoruninstructionset.h index 670a66458ff..9a4d0ba2ef9 100644 --- a/src/coreclr/inc/readytoruninstructionset.h +++ b/src/coreclr/inc/readytoruninstructionset.h @@ -2,8 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat #ifndef READYTORUNINSTRUCTIONSET_H #define READYTORUNINSTRUCTIONSET_H diff --git a/src/coreclr/jit/ICorJitInfo_API_names.h b/src/coreclr/jit/ICorJitInfo_API_names.h index d9a6719efcd..d5a683a1217 100644 --- a/src/coreclr/jit/ICorJitInfo_API_names.h +++ b/src/coreclr/jit/ICorJitInfo_API_names.h @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md DEF_CLR_API(getMethodAttribs) DEF_CLR_API(setMethodAttribs) diff --git a/src/coreclr/jit/ICorJitInfo_API_wrapper.hpp b/src/coreclr/jit/ICorJitInfo_API_wrapper.hpp index 9a9723a0c4b..fb10358a412 100644 --- a/src/coreclr/jit/ICorJitInfo_API_wrapper.hpp +++ b/src/coreclr/jit/ICorJitInfo_API_wrapper.hpp @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md #define API_ENTER(name) wrapComp->CLR_API_Enter(API_##name); diff --git a/src/coreclr/pal/prebuilt/idl/clrdata_i.cpp b/src/coreclr/pal/prebuilt/idl/clrdata_i.cpp index d88a456414d..7d6b61a14f1 100644 --- a/src/coreclr/pal/prebuilt/idl/clrdata_i.cpp +++ b/src/coreclr/pal/prebuilt/idl/clrdata_i.cpp @@ -9,7 +9,7 @@ /* File created by MIDL compiler version 8.01.0622 */ /* at Mon Jan 18 19:14:07 2038 */ -/* Compiler settings for C:/ssd/runtime/src/coreclr/src/inc/clrdata.idl: +/* Compiler settings for C:/ssd/runtime/src/coreclr/inc/clrdata.idl: Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data diff --git a/src/coreclr/pal/prebuilt/idl/sospriv_i.cpp b/src/coreclr/pal/prebuilt/idl/sospriv_i.cpp index 44e6f3ca739..c00c70a183b 100644 --- a/src/coreclr/pal/prebuilt/idl/sospriv_i.cpp +++ b/src/coreclr/pal/prebuilt/idl/sospriv_i.cpp @@ -8,7 +8,7 @@ /* File created by MIDL compiler version 8.01.0622 */ /* at Mon Jan 18 19:14:07 2038 */ -/* Compiler settings for C:/ssd/runtime/src/coreclr/src/inc/sospriv.idl: +/* Compiler settings for C:/ssd/runtime/src/coreclr/inc/sospriv.idl: Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data diff --git a/src/coreclr/pal/prebuilt/inc/clrdata.h b/src/coreclr/pal/prebuilt/inc/clrdata.h index b0675c9d43a..29f72974c5c 100644 --- a/src/coreclr/pal/prebuilt/inc/clrdata.h +++ b/src/coreclr/pal/prebuilt/inc/clrdata.h @@ -7,7 +7,7 @@ /* File created by MIDL compiler version 8.01.0622 */ /* at Mon Jan 18 19:14:07 2038 */ -/* Compiler settings for C:/ssd/runtime/src/coreclr/src/inc/clrdata.idl: +/* Compiler settings for C:/ssd/runtime/src/coreclr/inc/clrdata.idl: Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data diff --git a/src/coreclr/pal/prebuilt/inc/corprof.h b/src/coreclr/pal/prebuilt/inc/corprof.h index 9a1e4b490a6..2311aa50686 100644 --- a/src/coreclr/pal/prebuilt/inc/corprof.h +++ b/src/coreclr/pal/prebuilt/inc/corprof.h @@ -6,7 +6,7 @@ /* File created by MIDL compiler version 8.01.0622 */ /* at Mon Jan 18 19:14:07 2038 */ -/* Compiler settings for C:/git/runtime/src/coreclr/src/inc/corprof.idl: +/* Compiler settings for C:/git/runtime/src/coreclr/inc/corprof.idl: Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data diff --git a/src/coreclr/pal/prebuilt/inc/sospriv.h b/src/coreclr/pal/prebuilt/inc/sospriv.h index 38bb6791ea1..a2d4bfb49ef 100644 --- a/src/coreclr/pal/prebuilt/inc/sospriv.h +++ b/src/coreclr/pal/prebuilt/inc/sospriv.h @@ -6,7 +6,7 @@ /* File created by MIDL compiler version 8.01.0622 */ /* at Mon Jan 18 19:14:07 2038 */ -/* Compiler settings for C:/git/runtime/src/coreclr/src/inc/sospriv.idl: +/* Compiler settings for C:/git/runtime/src/coreclr/inc/sospriv.idl: Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data diff --git a/src/coreclr/pal/prebuilt/inc/xcordebug.h b/src/coreclr/pal/prebuilt/inc/xcordebug.h index f19f96589df..7ad62e31757 100644 --- a/src/coreclr/pal/prebuilt/inc/xcordebug.h +++ b/src/coreclr/pal/prebuilt/inc/xcordebug.h @@ -6,7 +6,7 @@ /* File created by MIDL compiler version 8.01.0622 */ /* at Mon Jan 18 19:14:07 2038 */ -/* Compiler settings for F:/Dev/coreclr/src/inc/xcordebug.idl: +/* Compiler settings for F:/Dev/coreclr/inc/xcordebug.idl: Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data diff --git a/src/coreclr/pal/src/exception/seh-unwind.cpp b/src/coreclr/pal/src/exception/seh-unwind.cpp index 5db8a80a88c..5f4df9ae4dc 100644 --- a/src/coreclr/pal/src/exception/seh-unwind.cpp +++ b/src/coreclr/pal/src/exception/seh-unwind.cpp @@ -529,7 +529,7 @@ Parameters: Note: The name of this function and the name of the ExceptionRecord parameter is used in the sos lldb plugin code to read the exception - record. See coreclr\src\ToolBox\SOS\lldbplugin\services.cpp. + record. See coreclr\ToolBox\SOS\lldbplugin\services.cpp. This function must not be inlined or optimized so the below PAL_VirtualUnwind calls end up with RaiseException caller's context and so the above debugger diff --git a/src/coreclr/scripts/scripts.pyproj b/src/coreclr/scripts/scripts.pyproj index a36591d2834..37e587d8833 100644 --- a/src/coreclr/scripts/scripts.pyproj +++ b/src/coreclr/scripts/scripts.pyproj @@ -12,7 +12,7 @@ <ProjectTypeGuids>{888888a0-9f3d-457c-b088-3a5042f75d52}</ProjectTypeGuids> <LaunchProvider>Standard Python launcher</LaunchProvider> <InterpreterId>Global|PythonCore|2.7</InterpreterId> - <CommandLineArguments>--man c:\src\coreclr\src\vm\clretwall.man --intermediate c:\work\runtimeeventsource</CommandLineArguments> + <CommandLineArguments>--man c:\src\coreclr\vm\clretwall.man --intermediate c:\work\runtimeeventsource</CommandLineArguments> <EnableNativeCodeDebugging>False</EnableNativeCodeDebugging> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)' == 'Debug'" /> diff --git a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs index caee23c7e81..e003ff6c930 100644 --- a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs +++ b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs @@ -7,7 +7,7 @@ namespace Internal.Runtime { // // Please keep the data structures in this file in sync with the native version at - // src/coreclr/src/inc/readytorun.h + // src/coreclr/inc/readytorun.h // internal struct ReadyToRunHeaderConstants diff --git a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSet.cs b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSet.cs index c4b646cb22d..5a1093e1dbc 100644 --- a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSet.cs +++ b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSet.cs @@ -2,8 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat using System; using System.Runtime.InteropServices; diff --git a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs index 059f13eba29..e064a954e60 100644 --- a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs +++ b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs @@ -2,8 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat using System; using System.Runtime.InteropServices; diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoBase.cs b/src/coreclr/tools/Common/JitInterface/CorInfoBase.cs index 1e87eb90e9b..2326320e34e 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoBase.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoBase.cs @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md using System; diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoInstructionSet.cs b/src/coreclr/tools/Common/JitInterface/CorInfoInstructionSet.cs index 4fc31bd7f34..4270c1e69c1 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoInstructionSet.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoInstructionSet.cs @@ -2,8 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat using System; using System.Collections; diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.VarInfo.cs b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.VarInfo.cs index 5e84af72a4c..8808979a79b 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.VarInfo.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.VarInfo.cs @@ -53,7 +53,7 @@ namespace Internal.JitInterface /* Changes to the following types may require revisiting the above layout. - In coreclr\src\inc\cordebuginfo.h + In coreclr\inc\cordebuginfo.h enum VarLocType { diff --git a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetGenerator.cs b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetGenerator.cs index 05019075c77..aeece525566 100644 --- a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetGenerator.cs +++ b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetGenerator.cs @@ -248,8 +248,8 @@ namespace Thunkerator // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat using System; using System.Runtime.InteropServices; @@ -277,8 +277,8 @@ namespace Internal.ReadyToRunConstants // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat using System; using System.Runtime.InteropServices; @@ -349,8 +349,8 @@ namespace Internal.ReadyToRunConstants // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat using System; using System.Collections; @@ -636,8 +636,8 @@ namespace Internal.JitInterface // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat #ifndef CORINFOINSTRUCTIONSET_H #define CORINFOINSTRUCTIONSET_H @@ -856,8 +856,8 @@ inline CORINFO_InstructionSet InstructionSetFromR2RInstructionSet(ReadyToRunInst // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// FROM /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt -// using /src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/gen.bat +// FROM /src/coreclr/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +// using /src/coreclr/tools/Common/JitInterface/ThunkGenerator/gen.bat #ifndef READYTORUNINSTRUCTIONSET_H #define READYTORUNINSTRUCTIONSET_H diff --git a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/Program.cs b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/Program.cs index c7e97f4aea7..f8b9a16a2be 100644 --- a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/Program.cs +++ b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/Program.cs @@ -265,7 +265,7 @@ namespace Thunkerator // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md "); } diff --git a/src/coreclr/tools/ILVerification/README.md b/src/coreclr/tools/ILVerification/README.md index 48ed8724f66..0f8821d9938 100644 --- a/src/coreclr/tools/ILVerification/README.md +++ b/src/coreclr/tools/ILVerification/README.md @@ -1,3 +1,3 @@ # ILVerification -The ILVerification library is part of the ILVerify project. See details under [src/coreclr/src/tools/ILVerify](../ILVerify). +The ILVerification library is part of the ILVerify project. See details under [src/coreclr/tools/ILVerify](../ILVerify). diff --git a/src/coreclr/tools/ILVerify/README.md b/src/coreclr/tools/ILVerify/README.md index fcab2c2d848..23175857e87 100644 --- a/src/coreclr/tools/ILVerify/README.md +++ b/src/coreclr/tools/ILVerify/README.md @@ -95,6 +95,6 @@ All ILVerify issues are labeled with [area-ILVerification](https://github.com/se Useful sources: - [PEVerify source code](https://github.com/lewischeng-ms/sscli/blob/master/clr/src/jit64/newverify.cpp) - - [RyuJIT source code](https://github.com/dotnet/runtime/tree/master/src/coreclr/src/jit), specifically: [exception handling specific part](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/jiteh.cpp), [importer.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/importer.cpp) (look for `Compiler::ver`, `Verify`, `VerifyOrReturn`, and `VerifyOrReturnSpeculative`), [_typeinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/_typeinfo.h), [typeinfo.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/jit/typeinfo.cpp) + - [RyuJIT source code](https://github.com/dotnet/runtime/tree/master/src/coreclr/jit), specifically: [exception handling specific part](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/jiteh.cpp), [importer.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/importer.cpp) (look for `Compiler::ver`, `Verify`, `VerifyOrReturn`, and `VerifyOrReturnSpeculative`), [_typeinfo.h](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/_typeinfo.h), [typeinfo.cpp](https://github.com/dotnet/runtime/blob/master/src/coreclr/jit/typeinfo.cpp) - [ECMA-335 standard](https://www.ecma-international.org/publications/standards/Ecma-335.htm) - [Expert .NET 2.0 IL Assembler book](http://www.apress.com/us/book/9781590596463) by Serge Lidin diff --git a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs index 486f60e091b..59c455a0859 100644 --- a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs +++ b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs @@ -84,7 +84,7 @@ namespace ILCompiler.Reflection.ReadyToRun /// A runtime function corresponds to a contiguous fragment of code that implements a method. /// </summary> /// <remarks> - /// Based on <a href="https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/inc/pal.h">src/pal/inc/pal.h</a> _RUNTIME_FUNCTION + /// Based on <a href="https://github.com/dotnet/runtime/blob/master/src/coreclr/pal/inc/pal.h">src/pal/inc/pal.h</a> _RUNTIME_FUNCTION /// </remarks> public class RuntimeFunction { diff --git a/src/coreclr/tools/aot/jitinterface/jitinterface.h b/src/coreclr/tools/aot/jitinterface/jitinterface.h index fa2c9e71699..e7a9609b6e4 100644 --- a/src/coreclr/tools/aot/jitinterface/jitinterface.h +++ b/src/coreclr/tools/aot/jitinterface/jitinterface.h @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED -// To regenerate run the gen script in src/coreclr/src/tools/Common/JitInterface/ThunkGenerator +// To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator // and follow the instructions in docs/project/updating-jitinterface.md diff --git a/src/coreclr/vm/compile.cpp b/src/coreclr/vm/compile.cpp index 3f18c36acc7..616c0e58e01 100644 --- a/src/coreclr/vm/compile.cpp +++ b/src/coreclr/vm/compile.cpp @@ -4602,7 +4602,7 @@ static BOOL CanSatisfyConstraints(Instantiation typicalInst, Instantiation candi // -// This method has duplicated logic from coreclr\src\System.Private.CoreLib\src\System\Collections\Generic\ComparerHelpers.cs +// This method has duplicated logic from coreclr\System.Private.CoreLib\src\System\Collections\Generic\ComparerHelpers.cs // static void SpecializeComparer(SString& ss, Instantiation& inst) { @@ -4656,7 +4656,7 @@ static void SpecializeComparer(SString& ss, Instantiation& inst) } // -// This method has duplicated logic from coreclr\src\System.Private.CoreLib\src\System\Collections\Generic\ComparerHelpers.cs +// This method has duplicated logic from coreclr\System.Private.CoreLib\src\System\Collections\Generic\ComparerHelpers.cs // and matching logic in jitinterface.cpp // static void SpecializeEqualityComparer(SString& ss, Instantiation& inst) diff --git a/src/libraries/GenerateLibrariesSln.ps1 b/src/libraries/GenerateLibrariesSln.ps1 index e3e8531edb2..8805a8ba94b 100644 --- a/src/libraries/GenerateLibrariesSln.ps1 +++ b/src/libraries/GenerateLibrariesSln.ps1 @@ -35,5 +35,5 @@ foreach ($f in Get-ChildItem -Recurse -Path $([System.IO.Path]::Combine("*", $ty if ($type -eq "src") { # Also add CoreLib if this is for src projects - dotnet sln $SolutionName add --in-root $f.FullName $([System.IO.Path]::Combine("..", "coreclr", "src", "System.Private.CoreLib", "System.Private.CoreLib.csproj")) + dotnet sln $SolutionName add --in-root $f.FullName $([System.IO.Path]::Combine("..", "coreclr", "System.Private.CoreLib", "System.Private.CoreLib.csproj")) } diff --git a/src/libraries/System.AppContext/System.AppContext.sln b/src/libraries/System.AppContext/System.AppContext.sln index 90c5de42be3..a2adc157233 100644 --- a/src/libraries/System.AppContext/System.AppContext.sln +++ b/src/libraries/System.AppContext/System.AppContext.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{751F6E52-BD51-406F-9EB6-06D3C27BF469}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{751F6E52-BD51-406F-9EB6-06D3C27BF469}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{F9B2FCA3-69C0-45A6-B1FA-E989263536C4}" EndProject diff --git a/src/libraries/System.Buffers/System.Buffers.sln b/src/libraries/System.Buffers/System.Buffers.sln index 166ac1588dd..004ffc23349 100644 --- a/src/libraries/System.Buffers/System.Buffers.sln +++ b/src/libraries/System.Buffers/System.Buffers.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{006429DB-0860-4688-BD1D-459C9364594D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{006429DB-0860-4688-BD1D-459C9364594D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{350A679C-F690-49B3-AB97-340AF05E1250}" EndProject diff --git a/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln b/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln index 8c31f04ca89..4caef513dc2 100644 --- a/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln +++ b/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{A8E6D68A-AFEE-4B68-ACE1-074CD1BCC322}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{A8E6D68A-AFEE-4B68-ACE1-074CD1BCC322}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{7C2B8279-F7BB-4AD4-BA44-B9071090AF46}" EndProject diff --git a/src/libraries/System.Collections/System.Collections.sln b/src/libraries/System.Collections/System.Collections.sln index 4a97408e014..5d692a6d1e3 100644 --- a/src/libraries/System.Collections/System.Collections.sln +++ b/src/libraries/System.Collections/System.Collections.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{4385739F-14A1-4F21-96E3-12EA90580575}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{4385739F-14A1-4F21-96E3-12EA90580575}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{38D8F258-655E-459B-B2CE-0DED144AFBF7}" EndProject diff --git a/src/libraries/System.Data.Common/System.Data.Common.sln b/src/libraries/System.Data.Common/System.Data.Common.sln index c70eb872163..f1745ac2cbc 100644 --- a/src/libraries/System.Data.Common/System.Data.Common.sln +++ b/src/libraries/System.Data.Common/System.Data.Common.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{F3DC1DF9-698A-4970-9A5E-AB946D6F763B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{F3DC1DF9-698A-4970-9A5E-AB946D6F763B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{0BD22D2A-C12C-4641-8F12-73D21AAAFBA3}" EndProject diff --git a/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln b/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln index f92fd9a4f31..9debd259766 100644 --- a/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln +++ b/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{D5A81248-C2F8-464A-8EA4-2AB2528206BC}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{D5A81248-C2F8-464A-8EA4-2AB2528206BC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{E4B95B10-EC2A-4874-8E71-858A90A4BDFE}" EndProject diff --git a/src/libraries/System.Diagnostics.Debug/System.Diagnostics.Debug.sln b/src/libraries/System.Diagnostics.Debug/System.Diagnostics.Debug.sln index ecd12e97e0e..b565dc3eb31 100644 --- a/src/libraries/System.Diagnostics.Debug/System.Diagnostics.Debug.sln +++ b/src/libraries/System.Diagnostics.Debug/System.Diagnostics.Debug.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{6CBF7573-4865-4DD2-A38B-74003FB43C9E}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{6CBF7573-4865-4DD2-A38B-74003FB43C9E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{1C01EFBD-2332-4392-BB4A-918178861EDC}" EndProject diff --git a/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln b/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln index 064c4f11102..e045045c800 100644 --- a/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln +++ b/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E34F351F-8EB7-4D44-BA44-85F791F662CC}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E34F351F-8EB7-4D44-BA44-85F791F662CC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{65FFFD20-CE5D-4FC0-A525-1C308186A16F}" EndProject diff --git a/src/libraries/System.Diagnostics.Tools/System.Diagnostics.Tools.sln b/src/libraries/System.Diagnostics.Tools/System.Diagnostics.Tools.sln index 998703f735c..ac162dd3f84 100644 --- a/src/libraries/System.Diagnostics.Tools/System.Diagnostics.Tools.sln +++ b/src/libraries/System.Diagnostics.Tools/System.Diagnostics.Tools.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{4E534B56-D245-41B7-B4D0-F8AB7BCC8877}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{4E534B56-D245-41B7-B4D0-F8AB7BCC8877}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{6FF6D8F0-403D-40DF-9D75-895E2AF22B88}" EndProject diff --git a/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln b/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln index ae5060c54c8..7a590b036b3 100644 --- a/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln +++ b/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{89B01AF7-F0CE-4168-8C4A-33FCDCF33B73}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{89B01AF7-F0CE-4168-8C4A-33FCDCF33B73}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{F6BCA6EF-777E-408B-B49B-B055B5A0BA19}" EndProject diff --git a/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln b/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln index fd3321e9d15..34c6d34dd56 100644 --- a/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln +++ b/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{370DCE61-CBDF-466E-91DB-5AE622BF2E52}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{370DCE61-CBDF-466E-91DB-5AE622BF2E52}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{6E159831-C97C-40FD-AD1A-E8B1EE3E7168}" EndProject diff --git a/src/libraries/System.Globalization.Calendars/System.Globalization.Calendars.sln b/src/libraries/System.Globalization.Calendars/System.Globalization.Calendars.sln index 14313ef439a..3f5e76742b4 100644 --- a/src/libraries/System.Globalization.Calendars/System.Globalization.Calendars.sln +++ b/src/libraries/System.Globalization.Calendars/System.Globalization.Calendars.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E70B35E3-B6C3-4196-9FAB-1A0D45748E79}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E70B35E3-B6C3-4196-9FAB-1A0D45748E79}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{32F01C47-D495-45CE-9567-E4C434F7D627}" EndProject diff --git a/src/libraries/System.Globalization/System.Globalization.sln b/src/libraries/System.Globalization/System.Globalization.sln index 73c181f6928..508ce915321 100644 --- a/src/libraries/System.Globalization/System.Globalization.sln +++ b/src/libraries/System.Globalization/System.Globalization.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E269F8BB-F629-4C96-B9B2-03A00D8B1BFB}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E269F8BB-F629-4C96-B9B2-03A00D8B1BFB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities.Unicode", "..\Common\tests\TestUtilities.Unicode\TestUtilities.Unicode.csproj", "{79613DED-481D-44EF-BB89-7AC6BD53026B}" EndProject diff --git a/src/libraries/System.IO.UnmanagedMemoryStream/System.IO.UnmanagedMemoryStream.sln b/src/libraries/System.IO.UnmanagedMemoryStream/System.IO.UnmanagedMemoryStream.sln index 8fe751b8ace..e0d7f1dcff1 100644 --- a/src/libraries/System.IO.UnmanagedMemoryStream/System.IO.UnmanagedMemoryStream.sln +++ b/src/libraries/System.IO.UnmanagedMemoryStream/System.IO.UnmanagedMemoryStream.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{074D8726-9CC3-43B5-9D28-1AD33A6100F7}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{074D8726-9CC3-43B5-9D28-1AD33A6100F7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{7DC8F0E9-5D6C-47F7-AE83-9AB1180AF51E}" EndProject diff --git a/src/libraries/System.Memory/System.Memory.sln b/src/libraries/System.Memory/System.Memory.sln index 6db556d3fb9..63f9436b6ad 100644 --- a/src/libraries/System.Memory/System.Memory.sln +++ b/src/libraries/System.Memory/System.Memory.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{7746BFD6-E6D6-4703-AA2D-43380B5DEA22}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{7746BFD6-E6D6-4703-AA2D-43380B5DEA22}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{6A54FACA-933E-4C1D-92AB-1A5506CFC212}" EndProject diff --git a/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln b/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln index 850c9665498..f1f46e31e9e 100644 --- a/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln +++ b/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{634A3B2B-09F5-4810-B630-ADE4D36C47DF}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{634A3B2B-09F5-4810-B630-ADE4D36C47DF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{9EDBE037-EFE0-4B72-B602-E4C3F0C05F2F}" EndProject diff --git a/src/libraries/System.Private.CoreLib/src/README.md b/src/libraries/System.Private.CoreLib/src/README.md index 510365ed965..0d1fd90fb45 100644 --- a/src/libraries/System.Private.CoreLib/src/README.md +++ b/src/libraries/System.Private.CoreLib/src/README.md @@ -13,7 +13,7 @@ Any runtime-specific `partial` part which also has a shared part sholud use a ru ## System.Private.CoreLib CoreCLR Sources -The CoreCLR specific sources can be found at [src/coreclr/src/System.Private.CoreLib](../../../coreclr/src/System.Private.CoreLib/). +The CoreCLR specific sources can be found at [src/coreclr/System.Private.CoreLib](../../../coreclr/System.Private.CoreLib/). ## System.Private.CoreLib Mono Sources diff --git a/src/libraries/System.Private.Uri/System.Private.Uri.sln b/src/libraries/System.Private.Uri/System.Private.Uri.sln index 65923b8c668..7c0aab144c3 100644 --- a/src/libraries/System.Private.Uri/System.Private.Uri.sln +++ b/src/libraries/System.Private.Uri/System.Private.Uri.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{C150B694-015F-48BD-8CB0-EFF1F7A84DCE}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{C150B694-015F-48BD-8CB0-EFF1F7A84DCE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{ADD88187-83E2-4EAF-BFB4-BC6249E76457}" EndProject diff --git a/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln b/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln index 286192f00fe..55560fdb822 100644 --- a/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln +++ b/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{B1053D24-237E-4E55-9413-20B34ED79F23}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{B1053D24-237E-4E55-9413-20B34ED79F23}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{05696F45-ACF1-4C02-B8D9-E8C1F5E28717}" EndProject diff --git a/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln b/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln index a5c9aeaf1bd..a0a4045b318 100644 --- a/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln +++ b/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{209EDA22-1D20-4180-BE4C-53DEE1758B5D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{209EDA22-1D20-4180-BE4C-53DEE1758B5D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{ECDDE645-347C-46D8-B6B6-BCFF6B9AFD4A}" EndProject diff --git a/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln b/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln index c7b9fee3009..8aa13fb858d 100644 --- a/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln +++ b/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{772C93D4-FC45-46AA-B09F-26F01B672EDC}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{772C93D4-FC45-46AA-B09F-26F01B672EDC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{E5543842-139D-43BD-B604-E65EBB91649E}" EndProject diff --git a/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln b/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln index 1f755200fcd..b018c7d177e 100644 --- a/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln +++ b/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{661E0A3D-E151-45B2-AA38-B30F8227A741}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{661E0A3D-E151-45B2-AA38-B30F8227A741}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitives", "ref\System.Reflection.Primitives.csproj", "{9D308994-9721-4883-B32D-531FA8D9025B}" EndProject diff --git a/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln b/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln index 305bea700e6..ad0546d656b 100644 --- a/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln +++ b/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{F3F9D019-086A-4093-BD49-11B6B204D94A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{F3F9D019-086A-4093-BD49-11B6B204D94A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{41438432-4DC0-4724-8C8F-0D100083490F}" EndProject diff --git a/src/libraries/System.Reflection/System.Reflection.sln b/src/libraries/System.Reflection/System.Reflection.sln index 4ca98e05f23..5b47bef5c2f 100644 --- a/src/libraries/System.Reflection/System.Reflection.sln +++ b/src/libraries/System.Reflection/System.Reflection.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{27A1A006-6882-4C70-AB81-775D3D2C95A2}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{27A1A006-6882-4C70-AB81-775D3D2C95A2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{C5A7E7E7-E43B-4C87-9A92-13C3C817E714}" EndProject diff --git a/src/libraries/System.Resources.ResourceManager/System.Resources.ResourceManager.sln b/src/libraries/System.Resources.ResourceManager/System.Resources.ResourceManager.sln index 49634bfcf0c..2ece47f7818 100644 --- a/src/libraries/System.Resources.ResourceManager/System.Resources.ResourceManager.sln +++ b/src/libraries/System.Resources.ResourceManager/System.Resources.ResourceManager.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{152966B3-6D3D-4318-B62D-224940A6B746}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{152966B3-6D3D-4318-B62D-224940A6B746}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{B93B5C05-FB28-4173-8786-57B42CFE38F3}" EndProject diff --git a/src/libraries/System.Runtime.Extensions/System.Runtime.Extensions.sln b/src/libraries/System.Runtime.Extensions/System.Runtime.Extensions.sln index d6bcd1af77c..b61a9738a25 100644 --- a/src/libraries/System.Runtime.Extensions/System.Runtime.Extensions.sln +++ b/src/libraries/System.Runtime.Extensions/System.Runtime.Extensions.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{5D8A8EF7-9A44-45C3-B7B2-B44A296A1BE7}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{5D8A8EF7-9A44-45C3-B7B2-B44A296A1BE7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{D7A1E176-1515-41FE-86D0-A46C82B87B05}" EndProject diff --git a/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln b/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln index dff4fac3a47..7400e16352b 100644 --- a/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln +++ b/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{94B59BA0-491F-4B59-ADFF-A057EC3EC835}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{94B59BA0-491F-4B59-ADFF-A057EC3EC835}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}" EndProject diff --git a/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln b/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln index 627fc6a427b..b138532035f 100644 --- a/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln +++ b/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{5965CFFE-886A-418C-854F-5967D91DE914}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{5965CFFE-886A-418C-854F-5967D91DE914}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.Intrinsics", "ref\System.Runtime.Intrinsics.csproj", "{28B808CE-B1F8-4B05-9ADA-8884525BD87F}" EndProject diff --git a/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln b/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln index c3a8075c8db..2412cb53943 100644 --- a/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln +++ b/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{64DDD2AF-BF90-4DD8-AC24-D2084DB8D558}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{64DDD2AF-BF90-4DD8-AC24-D2084DB8D558}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{D6D16FFD-FD76-4700-B456-1DC4D093D1B5}" EndProject diff --git a/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln b/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln index 4afbab31c93..ce7c6e74795 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln +++ b/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{096171D9-C978-4509-B9D3-B6DBCD78420D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{096171D9-C978-4509-B9D3-B6DBCD78420D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{25F48B11-0D57-47B7-88EE-7D407AFBA7B6}" EndProject diff --git a/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.sln b/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.sln Binary files differindex 40cb9c61ff5..cb761cce530 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.sln +++ b/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.sln diff --git a/src/libraries/System.Runtime/System.Runtime.sln b/src/libraries/System.Runtime/System.Runtime.sln index 1bc5f254a82..ee70b113d2c 100644 --- a/src/libraries/System.Runtime/System.Runtime.sln +++ b/src/libraries/System.Runtime/System.Runtime.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{71AB8240-F179-4B21-A8BE-8BE6CD774ED9}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{71AB8240-F179-4B21-A8BE-8BE6CD774ED9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities.Unicode", "..\Common\tests\TestUtilities.Unicode\TestUtilities.Unicode.csproj", "{9DF0247E-5B81-4EF3-82CA-3E70B3A56742}" EndProject diff --git a/src/libraries/System.Security.Principal/System.Security.Principal.sln b/src/libraries/System.Security.Principal/System.Security.Principal.sln index 6dc143b24f5..18b0f33df6b 100644 --- a/src/libraries/System.Security.Principal/System.Security.Principal.sln +++ b/src/libraries/System.Security.Principal/System.Security.Principal.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{45602EBE-1508-43A8-A398-1B92BD243557}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{45602EBE-1508-43A8-A398-1B92BD243557}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Security.Principal", "ref\System.Security.Principal.csproj", "{23171947-F933-47A6-9D1A-D43A186E7C43}" EndProject diff --git a/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln b/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln index 090f79a06f7..7d7777cb814 100644 --- a/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln +++ b/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E70D3A84-3053-4E44-82FC-A56A574BF6F8}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{E70D3A84-3053-4E44-82FC-A56A574BF6F8}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{CC6D3524-D6C8-468B-B908-CE746C1DB175}" EndProject diff --git a/src/libraries/System.Text.Encoding/System.Text.Encoding.sln b/src/libraries/System.Text.Encoding/System.Text.Encoding.sln index 38d88185148..04d2bc9e450 100644 --- a/src/libraries/System.Text.Encoding/System.Text.Encoding.sln +++ b/src/libraries/System.Text.Encoding/System.Text.Encoding.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{8E868804-E3B3-4933-BFA9-E69F7704B3A5}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{8E868804-E3B3-4933-BFA9-E69F7704B3A5}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{2B15EE47-1C5F-444F-A9CD-EABBE370718E}" EndProject diff --git a/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln b/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln index d92438f1e46..b6561b7ade0 100644 --- a/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln +++ b/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{2F704A4A-944B-487C-BB11-D66CA63F3B05}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{2F704A4A-944B-487C-BB11-D66CA63F3B05}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{A4B84F3E-9C18-4CF7-8CA8-9F4AA4A1634F}" EndProject diff --git a/src/libraries/System.Threading.Tasks.Extensions/System.Threading.Tasks.Extensions.sln b/src/libraries/System.Threading.Tasks.Extensions/System.Threading.Tasks.Extensions.sln index 2606005c035..2660a313451 100644 --- a/src/libraries/System.Threading.Tasks.Extensions/System.Threading.Tasks.Extensions.sln +++ b/src/libraries/System.Threading.Tasks.Extensions/System.Threading.Tasks.Extensions.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{CB976362-9258-4E98-B8C3-FAE11BDF3AA0}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{CB976362-9258-4E98-B8C3-FAE11BDF3AA0}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{FFB40D04-17A5-4F9B-BD47-994E5616ABD9}" EndProject diff --git a/src/libraries/System.Threading.Tasks/System.Threading.Tasks.sln b/src/libraries/System.Threading.Tasks/System.Threading.Tasks.sln index 9515601049f..25e707b9022 100644 --- a/src/libraries/System.Threading.Tasks/System.Threading.Tasks.sln +++ b/src/libraries/System.Threading.Tasks/System.Threading.Tasks.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{2738C2DB-E488-4EA2-B981-ADB8C520DCA6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{2738C2DB-E488-4EA2-B981-ADB8C520DCA6}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{695A5828-6CFC-4BE1-AE4E-6EC9796B4FC7}" EndProject diff --git a/src/libraries/System.Threading.Thread/System.Threading.Thread.sln b/src/libraries/System.Threading.Thread/System.Threading.Thread.sln index b4032340a25..2eff7f72eb3 100644 --- a/src/libraries/System.Threading.Thread/System.Threading.Thread.sln +++ b/src/libraries/System.Threading.Thread/System.Threading.Thread.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{B811926D-CFBB-4C22-80D2-0CCD566D980C}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{B811926D-CFBB-4C22-80D2-0CCD566D980C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{BF6A7CA7-DDF9-44D4-AD00-D807765663F9}" EndProject diff --git a/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln b/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln index d7fd11fe14e..52fccc7889d 100644 --- a/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln +++ b/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{BEACD8A1-3C09-450E-931F-561D44986BFB}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{BEACD8A1-3C09-450E-931F-561D44986BFB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{CD477FC8-AF27-46A2-A451-4A2D4C11600D}" EndProject diff --git a/src/libraries/System.Threading.Timer/System.Threading.Timer.sln b/src/libraries/System.Threading.Timer/System.Threading.Timer.sln index 85d457df678..193a06037b0 100644 --- a/src/libraries/System.Threading.Timer/System.Threading.Timer.sln +++ b/src/libraries/System.Threading.Timer/System.Threading.Timer.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{74D4C464-F319-4A9D-8F09-C50FDBA1547A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{74D4C464-F319-4A9D-8F09-C50FDBA1547A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{567E9CC8-5751-4786-BCC6-C2A6C38044DF}" EndProject diff --git a/src/libraries/System.Threading/System.Threading.sln b/src/libraries/System.Threading/System.Threading.sln index 61409afd22c..e5692b021e6 100644 --- a/src/libraries/System.Threading/System.Threading.sln +++ b/src/libraries/System.Threading/System.Threading.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\src\System.Private.CoreLib\System.Private.CoreLib.csproj", "{1F14F4DD-AE65-407B-9E10-F5786A847AD6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{1F14F4DD-AE65-407B-9E10-F5786A847AD6}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{387778C0-0405-4FE2-9D85-034254EAAD46}" EndProject diff --git a/src/mono/mono/eventpipe/ep-rt-mono.h b/src/mono/mono/eventpipe/ep-rt-mono.h index 6cc6636a5a1..62f88fb7942 100644 --- a/src/mono/mono/eventpipe/ep-rt-mono.h +++ b/src/mono/mono/eventpipe/ep-rt-mono.h @@ -1955,7 +1955,7 @@ ep_rt_mono_thread_yield (void) #endif } -// See src/coreclr/src/vm/spinlock.h for details. +// See src/coreclr/vm/spinlock.h for details. #if defined(TARGET_ARM) || defined(TARGET_ARM64) #define EP_SLEEP_START_THRESHOLD (5 * 1024) #else diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c index 1a3ee7456cb..e060e659371 100644 --- a/src/mono/mono/metadata/icall.c +++ b/src/mono/mono/metadata/icall.c @@ -126,7 +126,7 @@ //#define MONO_DEBUG_ICALLARRAY -// Inline with CoreCLR heuristics, https://github.com/dotnet/runtime/blob/385b4d4296f9c5cb82363565aa210a1a37f92d90/src/coreclr/src/vm/threads.cpp#L6344. +// Inline with CoreCLR heuristics, https://github.com/dotnet/runtime/blob/69e114c1abf91241a0eeecf1ecceab4711b8aa62/src/coreclr/vm/threads.cpp#L6408. // Minimum stack size should be sufficient to allow a typical non-recursive call chain to execute, // including potential exception handling and garbage collection. Used for probing for available // stack space through RuntimeHelpers.EnsureSufficientExecutionStack. diff --git a/src/mono/netcore/System.Private.CoreLib/src/System/RuntimeType.Mono.cs b/src/mono/netcore/System.Private.CoreLib/src/System/RuntimeType.Mono.cs index eb514d171cf..4950926f4a8 100644 --- a/src/mono/netcore/System.Private.CoreLib/src/System/RuntimeType.Mono.cs +++ b/src/mono/netcore/System.Private.CoreLib/src/System/RuntimeType.Mono.cs @@ -2491,7 +2491,7 @@ namespace System get { // See https://github.com/mono/mono/issues/18180 and - // https://github.com/dotnet/runtime/blob/f23e2796ab5f6fea71c9fdacac024822280253db/src/coreclr/src/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs#L1468-L1472 + // https://github.com/dotnet/runtime/blob/69e114c1abf91241a0eeecf1ecceab4711b8aa62/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs#L1505-L1509 if (ContainsGenericParameters && !GetRootElementType().IsGenericTypeDefinition) return null; |