| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
Update build.cmd to support spaces in coreclr checkout directory
|
|
The mscorlib build in build.sh was not correctly flowing __BuildType
into MSBuild, which caused us to always build a Debug mscorlib.
While I was in the area, I removed the defines for OSGroup (which are
unused, as we use __BuildOS instead) and cleaned up some of the property
switches so we always pass prefixed properties (the bare names are the
computed ones from our targets in msbuild).
|
|
|
|
Change build and tests scripts to detect VS2015 and use that if available by default
|
|
|
|
This allows building the Windows x86 version of CoreCLR by using "x86" for the BuildArch parameter of build.cmd. Note that CMAKE_SYSTEM_PROCESSOR is no longer used in Windows builds to set IS_64BIT_BUILD.
This change is enough to get CoreCLR to build but more changes are required for it to actually run correctly. In particular, the JIT compiler support for x86 is pretty limited at this point.
|
|
c_runtime/vprintf/test1 is disabled as casting NULL to va_list is
against the C specification.
Fix SetFilePointer tests on 32 bit platforms.
Define _FILE_OFFSET_BITS=64 so that we have long file support on 32 bit
platforms.
Implement context capture/restore for ARM.
Link libgcc_s before libunwind on ARM so C++ exceptions work.
Translate armasm to gas syntax.
Specify Thumb, VFPv3, ARMv7 for the ARM target.
Add ARM configuration to mscorlib build
Implement GetLogicalProcessorCacheSizeFromOS in PAL.
Set UNWIND_CONTEXT_IS_UCONTEXT_T from configure check.
|
|
Add help information regarding skiptestbuild option
|
|
This changes moves coreclr onto DNX (same version as corefx). Theoretically, this should allow these tests to target the desktop CLR. All of the old package.config files are gone and replaced with corresponding project.json files. The up front restore behavior is retained. Tests are now buildable individually, though not runnable in a similar fashion.
|
|
Especially with the builds of the tests, the diag logging significantly reduces TP in the build and seems to reduce parallelism a bit too. Change this to normal.
|
|
|
|
|
|
Build, Windows: Use Config instead of Build Type
|
|
CMAKE_BUILD_TYPE should not be used with multi-configuration toolsets like Visual Studio. This commit removes the dependence of the Windows build on CMAKE_BUILD_TYPE.
See (https://github.com/dotnet/coreclr/pull/1111#commitcomment-11562822).
|
|
|
|
Enable Whole Program Optimization (WPO) for the Release build on Windows
|
|
* Enables whole program optimization for release configuration
on Windows.
* Fixes all messages "/LTCG specified but no code generation required;
remove /LTCG from link command line to improve linker performance"
which slow down the build process.
* Fixes all messages "MSIL .netmodule or module compiled with /GL
found; restarting link with /LTCG; add /LTCG to the link command
line to improve linker performance" which slow down the build
process.
* The previous two fixes work in Release and Debug builds on Windows.
Issue-URL: #1086
|
|
|
|
|
|
The use of goto :eof in numerous places in the build and test scripts is problematic. If preceded by an echo or other command, it will overwrite the exit code and the script may return incorrectly. This was happening for buildtest, masking a recent ycompilation error in one of the tests.
Change all of the goto :eof's to exit /b.
|
|
|
|
This modifies the `build.cmd`, `build.sh`, and `buildtest.cmd` to only
remove previous output (binaries, intermediates, and logs) for the
selected configuration when the `clean` argument is specified.
This also modifies `runtest.cmd` to output log files in the same format
as `build.cmd`, `build.sh`, and `buildtest.cmd` do currently.
|
|
Trying to do "build linuxmscorlib vs2015" was resulting in an error due to the script trying to read %_msbuildexe% when _msbuildexe hadn't been defined. When that was addressed, mscorlib was then also failing to compile due to the csc compiler not understanding a flag that was being set in the response file based on UseRoslynCompiler not being set. This commit addresses both issues.
|
|
Previous it was required to have VS2013 but now VS2015 can also be used. The default is still 2013 though.
On a machine with both version installed it is possible to force VS2013/VS2015 with a parameter.
Note: Still some work has to be done to make compilation successfull on VS2015.
|
|
Adds and modifies CMakeLists.txt files to enable building of crossgen.exe from build.cmd for x64 processor on Windows. Also adds a step in build.cmd to generate native image for mscorlib.
[tfs-changeset: 1456454]
|
|
Conflicts:
build.cmd
|
|
non-zero code
|
|
* binaries is now bin, intermediates is now obj
* modifying unixmscorlib build to instead be linuxmscorlib + osxmscorlib.
* Change OS=Unix to OS=Linux/OS=OSX and modified properties to mimic corefx's TargetsUnix.
|
|
The Linux build instructions don't list CMake as a pre-requisite for
building mscorlib yet build.cmd errors out if it is not present on the
machine. CMake isn't actually necessary for this particular build so
instead of requiring users to install CMake when not needed I added code
to skip the CMake detection logic in this case.
|
|
|
|
This change fixes an issue where tests cannot be built alone as well as cleans up the paths. The general path cleanup was done so that the path format and variable names generally follow the main build of the coreclr repo. Some highlights are:
* Don't use Cmake as a directory name for intermediates, use intermediates instead.
* Disable 4820 warning (this is about padding) when building tests. Reduces noise in output significantly
* Some fixes in typos and casing in the project files and build scripts
|
|
|
|
|
|
Rework the output paths so that the OS may appear in them. This then follows the same form as corefx. This solves a number of problems:
1) When building unix mscorlib after the regular build, we would use the wrong intermediates for incremental.
2) When testing windows after building unix mscorlib we'd use the wrong outputs and fail.
This change removes our cmake directory and moves cmake generated files into intermediates (under OS/arch paths)
The reason is that the intermediates go under here when actually doing the build, and on unix based systems, we need to generate the cmake files for different builds into different directories for the purpose of preserving incremental builds.
Change clean behavior
Clean should simply delete the root binary. We also should not make assumptions about
whether necessary directories are available when we begin to build and should create them every time if
necessary.
Create directories as needed.
|
|
|
|
This will enable the 'local publish' of the CoreCLR package to a location where
it can be picked up by the CoreFx build. What this means is that you will be able
to build the CoreCLR package and use that to run the CoreFx tests on top of it.
Changes required to make this happen:
- Refactor the managed build to make sure the buildtools gets restored before
we attempt to use the targets it provides.
- Take a dependency to the Microsoft.DotNet.BuildTools to bring in the packages.targets
- Update the $(PackagesDir) to point to the <repo root>\packages to make it consistent with CoreFx
- Hook-up the LocalPackagePublish targets to the build of the CoreCLR NuGet packages
|
|
not on the path.
|
|
Fixes #178
|
|
Build script was accidentally wiping the return code of the first msbuild step, causing us to continue building even in failure. Fix this and do a little extra cleanup.
|
|
|
|
|
|
[tfs-changeset: 1407945]
|
