diff options
Diffstat (limited to 'Documentation/building')
| -rw-r--r-- | Documentation/building/crossgen.md | 43 | ||||
| -rw-r--r-- | Documentation/building/linux-instructions.md | 8 | ||||
| -rw-r--r-- | Documentation/building/osx-instructions.md | 20 | ||||
| -rw-r--r-- | Documentation/building/testing-with-corefx.md | 6 | ||||
| -rw-r--r-- | Documentation/building/viewing-jit-dumps.md | 2 | ||||
| -rw-r--r-- | Documentation/building/windows-instructions.md | 196 |
6 files changed, 120 insertions, 155 deletions
diff --git a/Documentation/building/crossgen.md b/Documentation/building/crossgen.md index c74a5e680a..bf013e2285 100644 --- a/Documentation/building/crossgen.md +++ b/Documentation/building/crossgen.md @@ -7,7 +7,7 @@ Introduction When you create a .NET assembly using C# compiler, your assembly contains only MSIL code. When the app runs, the JIT compiler translates the MSIL code into native code, before the CPU can execute them. This execution model has some advantages. For example, your assembly code can be portable across all platforms and architectures that support .NET Core. -However, this portability comes with a performance penalty. Your app starts up slower, because the JIT compiler has to spend time to translate the code. +However, this portability comes with a performance cost. Your app starts up more slowly, because the JIT compiler has to spend time to translate the code. To help make your app start up faster, CoreCLR includes a tool called CrossGen, which can pre-compile the MSIL code into native code. @@ -18,7 +18,7 @@ If you build CoreCLR yourself, the CrossGen tool (`crossgen.exe` on Windows, or If you install CoreCLR using a NuGet package, you can find CrossGen in the `tools` folder of the NuGet package. Regardless of how you obtain CrossGen, it is very important that it must match other CoreCLR binaries. -- If you build CrossGen yourself, you should use it with coreclr and mscorlib generated from the same build. Do not attempt to mix CrossGen from one build with binaries generated from another build. +- If you build CrossGen yourself, you should use it with runtime and `System.Private.CoreLib.dll` generated from the same build. Do not attempt to mix CrossGen from one build with binaries generated from another build. - If you install CrossGen from NuGet, make sure you use CrossGen from exactly the same NuGet package as the rest of your CoreCLR binaries. Do not attempt to mix binaries from multiple NuGet packages. If you do not follow the above rules, you are likely to encounter errors while running CrossGen. @@ -26,26 +26,30 @@ If you do not follow the above rules, you are likely to encounter errors while r Using CrossGen -------------- -In most cases, the build script automatically runs CrossGen to create the native image for mscorlib. -When this happens, you will find both `mscorlib.dll` and `mscorlib.ni.dll` in your output directory. -`mscorlib.dll` is the MSIL assembly created by the C# compiler, while `mscorlib.ni.dll` is the native image that contains CPU-specific code. -Once the build is done, you only need `mscorlib.ni.dll` to use CoreCLR. -As a matter of fact, most CoreCLR NuGet packages contain only `mscorlib.ni.dll`, without `mscorlib.dll` +In most cases, the build script automatically runs CrossGen to create the native image for `System.Private.CoreLib.dll` and `mscorlib.dll`. +When this happens, you will find `System.Private.CoreLib.ni.dll` and `mscorlib.ni.dll` in your output directory. +`System.Private.CoreLib.dll` and `mscorlib.dll` are the MSIL assemblies created by the C# compiler, while `System.Private.CoreLib.ni.dll` and `mscorlib.ni.dll` are the native images that contain CPU-specific code. +Once the build is done, you only need `System.Private.CoreLib.ni.dll` and `mscorlib.ni.dll` to use CoreCLR. +The original MSIL assemblies are no longer needed by the runtime. -If for some reason you did not get `mscorlib.ni.dll` with the rest of your CoreCLR, you can easily create it yourself using CrossGen. -First, make sure you have `crossgen.exe` (on Windows) or `crossgen` (other platforms) in the same directory as `mscorlib.dll`. -Then, run one of the following two commands (first command for Windows, second command for other platforms): +If you installed CoreCLR from a NuGet package, `System.Private.CoreLib.ni.dll` and `mscorlib.ni.dll` are included in the package. +If for some reason you did not get `System.Private.CoreLib.dll` or `mscorlib.ni.dll` with the rest of your CoreCLR, you can easily create it yourself using CrossGen. + +If your `System.Private.CoreLib.dll`, `mscorlib.dll` and JIT compiler (`clrjit.dll` on Windows or `libclrjit.*` on other platforms) are all in the same directory as CrossGen itself, you can compile `System.Private.CoreLib.dll` and `mscorlib.dll` with the following commands (first two commands for Windows, next two commands for other platforms): + + .\crossgen.exe System.Private.CoreLib.dll .\crossgen.exe mscorlib.dll + ./crossgen System.Private.CoreLib.dll ./crossgen mscorlib.dll -To create native images for other assemblies, the command line is slightly more complex: +If your files are scattered in different directories, or if you want to create native images for other assemblies, the command line is slightly more complex: - .\crossgen.exe /Platform_Assemblies_Paths "path1;path2;..." assemblyName.dll - ./crossgen /Platform_Assemblies_Paths "path1:path2:..." assemblyName.dll + .\crossgen.exe /JITPath path\clrjit.dll /Platform_Assemblies_Paths "path1;path2;..." path\assemblyName.dll + ./crossgen -JITPath path/libclrjit.so -Platform_Assemblies_Paths "path1:path2:..." path/assemblyName.dll -The /Platform_Assemblies_Paths is used to specify the location of all the dependencies of the input assembly. -You should use full paths for this locations. Relative paths do not always work. +The /Platform_Assemblies_Paths is used to specify the locations of all the dependencies of the input assembly, including the input assembly itself. +You should use full paths for these locations. Relative paths do not always work. If there are multiple paths, separate them with semicolons (`;`) on Windows, or colons (`:`) on non-Windows platforms. It is generally a good idea to enclose the path list in quotes to protect any special characters from the shell. @@ -53,14 +57,13 @@ Using native images ------------------- Running CrossGen on an assembly creates a "native image" file, with the extension of `.ni.dll` or `.ni.exe`. -You should include the native images in your app, at the same location where you normally install the MSIL assemblies. -Once you have included native images, you do not need to include the original MSIL assemblies in your apps. +You should include the native images in your app, either by replacing the original MSIL assmblies with the native images, or by putting the native images next to the MSIL assemblies. +When the native images are present, CoreCLR runtime will automatically use it instead of the original MSIL assemblies. Common errors ------------- The following are some of the command errors while creating or using native images: -- "Could not load file or assembly 'mscorlib.dll' or one of its dependencies. The native image could not be loaded, because it was generated for use by a different version of the runtime. (Exception from HRESULT: 0x80131059)": This error indicates that there is a mismatch between CrossGen and mscorlib.ni.dll. Make sure to use CrossGen and mscorlib.ni.dll from the same build or NuGet package. - "Error: Could not load file or assembly '...' or one of its dependencies. The system cannot find the file specified. (Exception from HRESULT: 0x80070002)": CrossGen wasn't able to find a particular dependency that it needs. Verify that you have the assembly specified in the error message, and make sure its location is included in `/Platform_Assemblies_Paths`. -- CoreCLR unable to initialize: While there are many possible causes of this error, one possibility is a mismatch between mscorlib.ni.dll and coreclr.dll (or libcoreclr.so). Make sure they come from the same build or NuGet package. -- "Unable to load Jit Compiler": Please get a copy of `clrjit.dll` (or `libclrjit.so` or `libclrjit.dylib`, depending on your platform), and place it in the same directory as CrossGen. You can either build `clrjit.dll` yourself, or get it from `Microsoft.NETCore.Jit` NuGet package. To avoid possible issues, please use `clrjit.dll` from the same build as `crossgen.exe` if possible. +- CoreCLR unable to initialize: While there are many possible causes of this error, one possibility is a mismatch between System.Private.CoreLib.ni.dll and coreclr.dll (or libcoreclr.so). Make sure they come from the same build or NuGet package. +- "Unable to load Jit Compiler": Please get a copy of `clrjit.dll` (or `libclrjit.so` or `libclrjit.dylib`, depending on your platform), and place it in the same directory as CrossGen (or use /JITPath option). You can either build `clrjit.dll` yourself, or get it from `Microsoft.NETCore.Jit` NuGet package. To avoid possible issues, please use `clrjit.dll` from the same build as `crossgen.exe` if possible. diff --git a/Documentation/building/linux-instructions.md b/Documentation/building/linux-instructions.md index c948ecde20..ddd4274b83 100644 --- a/Documentation/building/linux-instructions.md +++ b/Documentation/building/linux-instructions.md @@ -47,6 +47,10 @@ ellismg@linux:~$ sudo apt-get install cmake llvm-3.5 clang-3.5 lldb-3.6 lldb-3.6 You now have all the required components. +If you are using Fedora 23 or 24, then you will need to install the following packages: + +`$ sudo dnf install llvm cmake clang lldb-devel libunwind-devel lttng-ust-devel libuuid-devel libicu-devel` + Git Setup --------- @@ -57,6 +61,10 @@ Set the maximum number of file-handles To ensure that your system can allocate enough file-handles for the corefx build run `sysctl fs.file-max`. If it is less than 100000, add `fs.file-max = 100000` to `/etc/sysctl.conf`, and then run `sudo sysctl -p`. +On Fedora 23 or 24: + +`$ sudo dnf install mono-devel` + Build the Runtime and Microsoft Core Library ============================================= diff --git a/Documentation/building/osx-instructions.md b/Documentation/building/osx-instructions.md index 6d3469b2d9..9e6b913675 100644 --- a/Documentation/building/osx-instructions.md +++ b/Documentation/building/osx-instructions.md @@ -51,7 +51,25 @@ The CoreFX cryptography libraries are built on OpenSSL. The version of OpenSSL i ```sh brew install openssl -brew link --force openssl + +# We need to make the runtime libraries discoverable, as well as make +# pkg-config be able to find the headers and current ABI version. +# +# Ensure the paths we will need exist +mkdir -p /usr/local/lib/pkgconfig + +# The rest of these instructions assume a default Homebrew path of +# /usr/local/opt/<module>, with /usr/local being the answer to +# `brew --prefix`. +# +# Runtime dependencies +ln -s /usr/local/opt/openssl/lib/libcrypto.1.0.0.dylib /usr/local/lib/ +ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/ + +# Compile-time dependences (for pkg-config) +ln -s /usr/local/opt/openssl/lib/pkgconfig/libcrypto.pc /usr/local/lib/pkgconfig/ +ln -s /usr/local/opt/openssl/lib/pkgconfig/libssl.pc /usr/local/lib/pkgconfig/ +ln -s /usr/local/opt/openssl/lib/pkgconfig/openssl.pc /usr/local/lib/pkgconfig/ ``` Build the Runtime and Microsoft Core Library diff --git a/Documentation/building/testing-with-corefx.md b/Documentation/building/testing-with-corefx.md index 6609a0aaa7..4f9886f78d 100644 --- a/Documentation/building/testing-with-corefx.md +++ b/Documentation/building/testing-with-corefx.md @@ -7,7 +7,11 @@ It may be valuable to use CoreFX tests to validate your changes to CoreCLR or ms As part of building tests, CoreFX restores a copy of the runtime from myget, in order to update the runtime that is deployed, a special build property `BUILDTOOLS_OVERRIDE_RUNTIME` can be used. If this is set, the CoreFX testing targets will copy all the files in the folder it points to into the test folder, overwriting any files that exist. -To run tests, follow the procedure for [running tests in CoreFX](https://github.com/dotnet/corefx/blob/master/Documentation/building/windows-instructions.md). You can pass `/p:BUILDTOOLS_OVERRIDE_RUNTIME=<path-to-coreclr>\bin\Product\Windows_NT.x64.Release` to build.cmd to set this property. +To run tests, follow the procedure for [running tests in CoreFX](https://github.com/dotnet/corefx/blob/master/Documentation/building/windows-instructions.md). You can pass `/p:BUILDTOOLS_OVERRIDE_RUNTIME=<path-to-coreclr>\bin\Product\Windows_NT.x64.Release` to build.cmd to set this property, e.g. (note the space between the "--" and the "/p" option): + +``` +build.cmd -Release -- /p:BUILDTOOLS_OVERRIDE_RUNTIME=<root of coreclr repo>\bin\Product\Windows_NT.x64.Checked +``` **FreeBSD, Linux, NetBSD, OS X** diff --git a/Documentation/building/viewing-jit-dumps.md b/Documentation/building/viewing-jit-dumps.md index 5303b47626..607c5e63a0 100644 --- a/Documentation/building/viewing-jit-dumps.md +++ b/Documentation/building/viewing-jit-dumps.md @@ -35,7 +35,7 @@ The first thing we want to do is setup the .NET Core app we want to dump. Here a } ``` -You can find a list of RIDs and their corresponding OSes [here](http://dotnet.github.io/docs/core-concepts/rid-catalog.html). +You can find a list of RIDs and their corresponding OSes [here](https://docs.microsoft.com/en-us/dotnet/articles/core/rid-catalog). * Edit `Program.cs`, and call the method(s) you want to dump in there. Make sure they are, directly or indirectly, called from `Main`. In this example, we'll be looking at the disassembly of our custom function `InefficientJoin`: diff --git a/Documentation/building/windows-instructions.md b/Documentation/building/windows-instructions.md index f68ed2c8c7..8ba021bbf9 100644 --- a/Documentation/building/windows-instructions.md +++ b/Documentation/building/windows-instructions.md @@ -1,21 +1,19 @@ Build CoreCLR on Windows ======================== -These instructions will lead you through building CoreCLR and running a "Hello World" demo on Windows. +These instructions will lead you through building CoreCLR. -Environment -=========== +---------------- +#Environment You must install several components to build the CoreCLR and CoreFX repos. These instructions were tested on Windows 7+. -Visual Studio -------------- +## Visual Studio Visual Studio must be installed. Supported versions: +- [Visual Studio 2015](https://www.visualstudio.com/downloads/visual-studio-2015-downloads-vs) (Community, Professional, Enterprise). The community version is completely free. -- [Visual Studio 2015](https://www.visualstudio.com/downloads/visual-studio-2015-downloads-vs) (Community, Professional, Enterprise) - -To debug managed code, ensure you have installed atleast [Visual Studio 2015 Update 3](https://www.visualstudio.com/en-us/news/releasenotes/vs2015-update3-vs). +To debug managed code, ensure you have installed at least [Visual Studio 2015 Update 3](https://www.visualstudio.com/en-us/news/releasenotes/vs2015-update3-vs). Make sure that you install "VC++ Tools". By default, they will not be installed. @@ -23,166 +21,100 @@ To build for Arm32, you need to have [Windows SDK for Windows 10](https://develo Visual Studio Express is not supported. -CMake ------ +##CMake The CoreCLR repo build has been validated using CMake 3.5.2. - Install [CMake](http://www.cmake.org/download) for Windows. -- Add it to the PATH environment variable. +- Add its location (e.g. C:\Program Files (x86)\CMake\bin) to the PATH environment variable. + The installation script has a check box to do this, but you can do it yourself after the fact + following the instructions at [Adding to the Default PATH variable](#adding-to-the-default-path-variable) + + +##Python -Python ---------- Python is used in the build system. We are currently using python 2.7.9, although any recent (2.4+) version of Python should work, including Python 3. - Install [Python](https://www.python.org/downloads/) for Windows. -- Add it to the PATH environment variable. - -PowerShell ----------- -PowerShell is used in the build system. Ensure that it is accessible via the PATH environment variable. Typically this is %SYSTEMROOT%\System32\WindowsPowerShell\v1.0\. +- Add its location (e.g. C:\Python*\) to the PATH environment variable. + The installation script has a check box to do this, but you can do it yourself after the fact + following the instructions at [Adding to the Default PATH variable](#adding-to-the-default-path-variable) -Powershell version must be 3.0 or higher. This should be the case for Windows 8 and later builds. -- Windows 7 SP1 can install Powershell version 4 [here](https://www.microsoft.com/en-us/download/details.aspx?id=40855). +##Git -Git Setup ---------- +For actual user operations, it is often more convinient to use the GIT features built into Visual Studio 2015. +However the CoreCLR and the tests use the GIT command line utilities directly so you need to install them +for these to work properly. You can get it from -Clone the CoreCLR and CoreFX repositories (either upstream or a fork). +- Install [Git For Windows](https://git-for-windows.github.io/) +- Add its location (e.g. C:\Program Files\Git\cmd) to the PATH environment variable. + The installation script has a check box to do this, but you can do it yourself after the fact + following the instructions at [Adding to the Default PATH variable](#adding-to-the-default-path-variable) -```bat -C:\git>git clone https://github.com/dotnet/coreclr -C:\git>git clone https://github.com/dotnet/corefx -``` +##PowerShell +PowerShell is used in the build system. Ensure that it is accessible via the PATH environment variable. +Typically this is %SYSTEMROOT%\System32\WindowsPowerShell\v1.0\. -This guide assumes that you've cloned the CoreCLR and CoreFX repositories into C:\git using the default repo names. If your setup is different, you'll need to pay attention to the commands you run. The guide will always show you the current directory. +Powershell version must be 3.0 or higher. This should be the case for Windows 8 and later builds. +- Windows 7 SP1 can install Powershell version 4 [here](https://www.microsoft.com/en-us/download/details.aspx?id=40855). -The repository is configured to allow Git to make the right decision about handling CRLF. Specifically, if you are working on **Windows**, please ensure that **core.autocrlf** is set to **true**. On **non-Windows** platforms, please set it to **input**. +##DotNet Core SDK +While not strictly needed to build or tests the .NET Core repository, having the .NET Core SDK installed lets +you use the dotnet.exe command to run .NET Core applications in the 'normal' way. We use this in the +[Using Your Build](Documentation/workflow/UsingYourBuild.md) instructions. Visual Studio 2015 (update 3) should have +installed the .NET Core SDK, but in case it did not you can get it from the [Installing the .Net Core SDK](https://www.microsoft.com/net/core) page. -Demo directory --------------- +##Adding to the default PATH variable -In order to keep everything tidy, create a new directory for the files that you will build or acquire. +The commands above need to be on your command lookup path. Some installers will automatically add them to +the path as part of installation, but if not here is how you can do it. -```bat -c:\git>mkdir \coreclr-demo\runtime -c:\git>mkdir \coreclr-demo\ref +You can of course add a directory to the PATH environment variable with the syntax +``` + set PATH=%PATH%;DIRECTORY_TO_ADD_TO_PATH ``` +However the change above will only last until the command windows closes. You can make your change to +the PATH variable persistent by going to Control Panel -> System And Security -> System -> Advanced system settings -> Environment Variables, +and select the 'Path' variable in the 'System variables' (if you want to change it for all users) or 'User variables' (if you only want +to change it for the currnet user). Simply edit the PATH variable's value and add the directory (with a semicolon separator). -Build the Runtime -================= +------------------------------------- +#Building -To build CoreCLR, run `build.cmd` from the root of the coreclr repository. This will do a x64/Debug build of CoreCLR, its native components, mscorlib.dll, and the tests. +Once all the necessary tools are in place, building is trivial. Simply run build build.cmd script that lives at +the base of the repository. - C:\git\coreclr>build -rebuild +```bat + .\build [Lots of build spew] - Repo successfully built. - Product binaries are available at C:\git\coreclr\bin\Product\Windows_NT.x64.debug Test binaries are available at C:\git\coreclr\bin\tests\Windows_NT.x64.debug +``` -**Note:** To avoid building the tests, pass the 'skiptestbuild' option to build. - -**build -?** will list supported parameters. - -Check the build output. +As shown above the product will be placed in - Product binaries will be dropped in `bin\Product\<OS>.<arch>.<flavor>` folder. - A NuGet package, Microsoft.Dotnet.CoreCLR, will be created under `bin\Product\<OS>.<arch>.<flavor>\.nuget` folder. - Test binaries will be dropped under `bin\Tests\<OS>.<arch>.<flavor>` folder -You will see several files. The interesting ones are: - -- `corerun`: The command line host. This program loads and starts the CoreCLR runtime and passes the managed program you want to run to it. -- `coreclr.dll`: The CoreCLR runtime itself. -- `mscorlib.dll`: The core managed library for CoreCLR, which contains all of the fundamental data types and functionality. - -Copy these files into the demo directory. - -```bat -C:\git\coreclr>copy bin\Product\Windows_NT.x64.debug\clrjit.dll \coreclr-demo\runtime -C:\git\coreclr>copy bin\Product\Windows_NT.x64.debug\CoreRun.exe \coreclr-demo\runtime -C:\git\coreclr>copy bin\Product\Windows_NT.x64.debug\coreclr.dll \coreclr-demo\runtime -C:\git\coreclr>copy bin\Product\Windows_NT.x64.debug\mscorlib.dll \coreclr-demo\runtime -C:\git\coreclr>copy bin\Product\Windows_NT.x64.debug\System.Private.CoreLib.dll \coreclr-demo\runtime -``` - -Build the Framework -=================== - -Build the framework out of the corefx directory. +By default build generates a 'Debug' build type, that has extra checking (assert) compiled into it. You can +also build the 'release' version which does not have these checks - c:\git\corefx>build.cmd +The build places logs in `bin\Logs` and these are useful when the build fails. - [Lots of build spew] - - 0 Warning(s) - 0 Error(s) - Time Elapsed 00:03:14.53 - Build Exit Code = 0 - -It's also possible to add -rebuild to build.cmd to force it to delete the previously built assemblies. - -For the purposes of this demo, you need to copy a few required assemblies to the demo folder. - -```bat -C:\git\corefx>copy bin\Windows_NT.AnyCPU.Debug\System.Console\System.Console.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\Windows_NT.AnyCPU.Debug\System.Diagnostics.Debug\System.Diagnostics.Debug.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.IO\System.IO.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.IO.FileSystem.Primitives\System.IO.FileSystem.Primitives.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.Runtime\System.Runtime.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.Runtime.InteropServices\System.Runtime.InteropServices.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.Text.Encoding\System.Text.Encoding.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.Text.Encoding.Extensions\System.Text.Encoding.Extensions.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.Threading\System.Threading.dll \coreclr-demo\runtime -C:\git\corefx>copy bin\AnyOS.AnyCPU.Debug\System.Threading.Tasks\System.Threading.Tasks.dll \coreclr-demo\runtime -``` - -You also need to copy reference assemblies, which will be used during compilation. - -```bat -C:\git\corefx>copy bin\ref\System.Runtime\4.0.0.0\System.Runtime.dll \coreclr-demo\ref -C:\git\corefx>copy bin\ref\System.Console\4.0.0.0\System.Console.dll \coreclr-demo\ref -``` - -Compile the Demo -================ +The build places all of its output in the `bin` directory, so if you remove that directory you can force a +full rebuild. -Now you need a Hello World application to run. You can write your own, if you'd like. Here's a very simple one: +Build has a number of options that you can learn about using build -?. Some of the more important options are -```C# -using System; + * skiptests - don't build the tests. This can shorten build times quite a bit, but means you can't run tests. + * release - build the 'Release' build type that does not have extra development-time checking compiled in. + * -rebuild - force the build not to be incremental but to recompile everything. + You want this if you are going to do performance testing on your build. -public class Program -{ - public static void Main() - { - Console.WriteLine("Hello, Windows"); - Console.WriteLine("Love from CoreCLR."); - } -} -``` - -Personally, I'm partial to the one on corefxlab which will print a picture for you. Download the [corefxlab demo](https://raw.githubusercontent.com/dotnet/corefxlab/master/demos/CoreClrConsoleApplications/HelloWorld/HelloWorld.cs) to `\coreclr-demo`. - -Then you just need to build it, with csc, the .NET Framework C# compiler. It may be easier to do this step within the "Developer Command Prompt for VS2015", if csc is not in your path. Because you need to compile the app against the .NET Core surface area, you need to pass references to the contract assemblies you restored using NuGet: - -```bat -csc /nostdlib /noconfig /r:ref\System.Runtime.dll /r:ref\System.Console.dll /out:runtime\hello.exe hello.cs -``` - -Run the demo -============ - -You're ready to run Hello World! To do that, run corerun, passing the path to the managed exe, plus any arguments. In this case, no arguments are necessary. - -```bat -C:\coreclr-demo>cd runtime -C:\coreclr-demo\runtime>CoreRun.exe hello.exe -``` +See [Using Your Build](../workflow/UsingYourBuild.md) for instructions on running code with your build. -If `CoreRun.exe` fails for some reason, you will see an empty output. To diagnose the issue, you can use `/v` to switch verbose mode on: `CoreRun.exe /v hello.exe`. +See [Running Tests](../workflow/RunningTests.md) for instructions on running the tests. -Over time, this process will get easier. Thanks for trying out CoreCLR. Feel free to try a more interesting demo. |