Merge remote-tracking branch 'upstream/master' into icu-normalization-casing-idna

Author: ellismg

.gitignore

@@ -269,3 +269,6 @@ CMakeFiles/
 cmake_install.cmake
 CMakeCache.txt
 Makefile
+
+# Cross compilation
+cross/rootfs/*

CMakeLists.txt

@@ -15,9 +15,30 @@ set(CLR_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(VM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/vm)
 set(GENERATED_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/src/inc)
 
+function(clr_unknown_arch)
+    if (WIN32)
+        message(FATAL_ERROR "Only AMD64 and I386 are supported")
+    else()
+        message(FATAL_ERROR "Only AMD64, ARM64 and ARM are supported")
+    endif()
+endfunction()
+
 if(CMAKE_SYSTEM_NAME STREQUAL Linux)
     set(CLR_CMAKE_PLATFORM_UNIX 1)
-    set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
+    if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64)
+        set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL armv7l)
+        set(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM 1)
+        # Because we don't use CMAKE_C_COMPILER/CMAKE_CXX_COMPILER to use clang
+        # we have to set the triple by adding a compiler argument
+        add_compile_options(-target armv7-linux-gnueabihf)
+        add_compile_options(-mthumb)
+        add_compile_options(-mfpu=vfpv3)
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
+        set(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64 1)
+    else()
+        clr_unknown_arch()
+    endif()
     set(CLR_CMAKE_PLATFORM_LINUX 1)
 endif(CMAKE_SYSTEM_NAME STREQUAL Linux)
 
@@ -46,6 +67,24 @@ if(CMAKE_SYSTEM_NAME STREQUAL NetBSD)
 	set(CLR_CMAKE_PLATFORM_NETBSD 1)
 endif(CMAKE_SYSTEM_NAME STREQUAL NetBSD)
 
+if(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
+  set(CLR_CMAKE_PLATFORM_ARCH_ARM 1)
+elseif(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64)
+  set(CLR_CMAKE_PLATFORM_ARCH_ARM64 1)
+elseif(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
+  set(CLR_CMAKE_PLATFORM_ARCH_AMD64 1)
+elseif(WIN32)
+  if (CLR_CMAKE_TARGET_ARCH STREQUAL x64)
+    set(CLR_CMAKE_PLATFORM_ARCH_AMD64 1)
+    set(IS_64BIT_BUILD 1)
+  elseif(CLR_CMAKE_TARGET_ARCH STREQUAL x86)
+    set(CLR_CMAKE_PLATFORM_ARCH_I386 1)
+    set(IS_64BIT_BUILD 0)
+  else()
+    clr_unknown_arch()
+  endif()
+endif()
+
 if(WIN32)
     enable_language(ASM_MASM)
 else()
@@ -121,7 +160,7 @@ function(generate_exports_file inputFilename outputFilename)
   add_custom_command(
     OUTPUT ${outputFilename}
     COMMAND ${AWK} -f ${CMAKE_SOURCE_DIR}/${AWK_SCRIPT} ${inputFilename} >${outputFilename}
-    DEPENDS ${inputFilename}
+    DEPENDS ${inputFilename} ${CMAKE_SOURCE_DIR}/${AWK_SCRIPT}
     COMMENT "Generating exports file ${outputFilename}"
   )
   set_source_files_properties(${outputFilename}
@@ -203,21 +242,15 @@ add_subdirectory(src/pal/prebuilt/inc)
 
 if (WIN32)
   set(OVERRIDE_CMAKE_CXX_FLAGS 1)
-
-  # Set flag to indicate if this will be a 64bit Windows build
-  if(CMAKE_SYSTEM_PROCESSOR STREQUAL AMD64)
-    set(IS_64BIT_BUILD 1)
-  endif (CMAKE_SYSTEM_PROCESSOR STREQUAL AMD64)
-  
 elseif (CLR_CMAKE_PLATFORM_UNIX)  
   # Set flag to indicate if this will be a 64bit build
   # CMAKE_SYSTEM_PROCESSOR returns the value of `uname -p`.
   # For the AMD/Intel 64bit architecure two different strings are common.
   # Linux and Darwin identify it as "x86_64" while FreeBSD uses the
   # "amd64" string. Accept either of the two here.
-  if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64)
+  if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
     set(IS_64BIT_BUILD 1)  
-  endif (CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64)
+  endif (CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
 
   add_definitions(-DFEATURE_IMPLICIT_TLS)
 endif(WIN32)
@@ -255,6 +288,10 @@ add_compile_options(/wd4960 /wd4961 /wd4603 /wd4627 /wd4838 /wd4456 /wd4457 /wd4
 add_compile_options(/O1) # minimize space
 add_compile_options(/Zi) # enable debugging information
 
+if (CLR_CMAKE_PLATFORM_ARCH_I386)
+  add_compile_options(/Gz)
+endif (CLR_CMAKE_PLATFORM_ARCH_I386)
+
 add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:Relwithdebinfo>>:/GL>)
 
 if (IS_64BIT_BUILD EQUAL 1)
@@ -346,7 +383,6 @@ include_directories("src/pal/prebuilt/inc")
 if (CLR_CMAKE_PLATFORM_UNIX)
   include_directories("src/pal/inc")
   include_directories("src/pal/inc/rt")
-  include_directories("src/pal/inc/rt/cpp")
   include_directories("src/pal/src/safecrt")
 endif (CLR_CMAKE_PLATFORM_UNIX)
 
@@ -370,15 +406,25 @@ if (CLR_CMAKE_PLATFORM_UNIX)
 
   if(IS_64BIT_BUILD)
     add_definitions(-DBIT64=1)
-    add_definitions(-DFEATURE_PAL)
-  else (IS_64BIT_BUILD)
-    message(FATAL_ERROR "error: Detected non x86_64 target processor. Not supported!")
   endif(IS_64BIT_BUILD)
 
+  add_definitions(-DFEATURE_PAL)
+    
   if(CLR_CMAKE_PLATFORM_LINUX)
     add_definitions(-D__LINUX__=1)
-    message("Detected Linux x86_64")
-    add_definitions(-DLINUX64)
+    if(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
+      message("Detected Linux x86_64")
+      add_definitions(-DLINUX64)
+    elseif(CLR_CMAKE_PLATFORM_ARCH_ARM)
+      message("Detected Linux ARM")
+      add_definitions(-DLINUX32)
+    elseif(CLR_CMAKE_PLATFORM_ARCH_ARM64)
+      message("Detected Linux ARM64")
+      add_definitions(-DLINUX64)
+    else()
+      clr_unknown_arch()
+    endif()
+      
   endif(CLR_CMAKE_PLATFORM_LINUX)
   if(CLR_CMAKE_PLATFORM_DARWIN)
     message("Detected OSX x86_64")
@@ -404,12 +450,28 @@ add_definitions(-DNTDDI_VERSION=NTDDI_WIN8)
 if (IS_64BIT_BUILD EQUAL 1)
   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
     add_definitions(-DDBG_TARGET_AMD64_UNIX)
+    add_definitions(-D_TARGET_AMD64_=1)
+    add_definitions(-DDBG_TARGET_AMD64)
+  elseif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64)
+    add_definitions(-DDBG_TARGET_ARM64_UNIX)
+    add_definitions(-D_TARGET_ARM64_=1)
+    add_definitions(-DDBG_TARGET_ARM64)
+  else ()
+    # Windows is assumed in this path -- fix this
+    add_definitions(-DDBG_TARGET_AMD64)
+    add_definitions(-D_TARGET_AMD64_=1)
   endif (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
-  add_definitions(-D_TARGET_AMD64_=1)
-  add_definitions(-DDBG_TARGET_AMD64)
+elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
+  if (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
+    add_definitions(-DDBG_TARGET_ARM_UNIX)
+  endif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
+  add_definitions(-D_TARGET_ARM_=1)
+  add_definitions(-DDBG_TARGET_ARM)
+elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
+  add_definitions(-D_TARGET_X86_=1)
+  add_definitions(-DDBG_TARGET_X86)
 else ()
-  # TODO: Support this
-  message(FATAL_ERROR "Not Implemented!")
+  clr_unknown_arch()
 endif (IS_64BIT_BUILD EQUAL 1)
 
 if(WIN32)
@@ -425,10 +487,16 @@ if(WIN32)
     add_definitions(-DEnC_SUPPORTED)
 endif(WIN32)
 add_definitions(-DFEATURE_APPDOMAIN_RESOURCE_MONITORING)
-add_definitions(-DFEATURE_ARRAYSTUB_AS_IL)
+if(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_ARM OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
+    add_definitions(-DFEATURE_ARRAYSTUB_AS_IL)
+endif()
 if (CLR_CMAKE_PLATFORM_UNIX)
     add_definitions(-DFEATURE_STUBS_AS_IL)
-    add_definitions(-DUNIX_AMD64_ABI)
+    if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
+      add_definitions(-DUNIX_AMD64_ABI)
+    elseif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
+      add_definitions(-DUNIX_ARM_ABI)
+    endif()
 endif(CLR_CMAKE_PLATFORM_UNIX)
 add_definitions(-DFEATURE_ASYNC_IO)
 add_definitions(-DFEATURE_BCL_FORMATTING)
@@ -519,16 +587,27 @@ if(CLR_CMAKE_PLATFORM_UNIX)
     add_definitions(-DFEATURE_DBGIPC_TRANSPORT_VM)
 endif(CLR_CMAKE_PLATFORM_UNIX)
 
-if (IS_64BIT_BUILD EQUAL 1)
-add_definitions(-D_AMD64_)
-add_definitions(-D_AMD64_SIMULATOR_)
-add_definitions(-D_AMD64_SIMULATOR_PERF_)
-add_definitions(-D_AMD64_WORKAROUND_)
-add_definitions(-D_WIN64)
-add_definitions(-DAMD64)
+if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
+  add_definitions(-D_AMD64_)
+  add_definitions(-D_AMD64_SIMULATOR_)
+  add_definitions(-D_AMD64_SIMULATOR_PERF_)
+  add_definitions(-D_AMD64_WORKAROUND_)
+  add_definitions(-D_WIN64)
+  add_definitions(-DAMD64)
+elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
+  add_definitions(-D_WIN32)
+  add_definitions(-D_X86_)
+elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
+  add_definitions(-D_ARM_)
+  add_definitions(-DARM)
+  add_definitions(-D_WIN32)
+elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
+  add_definitions(-D_ARM64_)
+  add_definitions(-DARM64)
+  add_definitions(-D_WIN64)
 else ()
-# TODO - Support this
-endif (IS_64BIT_BUILD EQUAL 1)
+  clr_unknown_arch()
+endif ()
 
 add_definitions(-D_SKIP_IF_SIMULATOR_)
 add_definitions(-D_SECURE_SCL=0)
@@ -540,9 +619,20 @@ add_definitions(-DUNICODE)
 add_definitions(-D_UNICODE)
 
 if (IS_64BIT_BUILD EQUAL 1)
-  set(ARCH_SOURCES_DIR amd64)
+  if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 EQUAL 1)
+    set(ARCH_SOURCES_DIR amd64)
+  elseif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64 EQUAL 1)
+    set(ARCH_SOURCES_DIR arm64)
+  else ()
+    # Windows is assumed in this path -- fix this
+    set(ARCH_SOURCES_DIR amd64)
+  endif ()
 else ()
-  set(ARCH_SOURCES_DIR i386)
+  if (CLR_CMAKE_PLATFORM_ARCH_ARM)
+    set(ARCH_SOURCES_DIR arm)
+  else ()
+    set(ARCH_SOURCES_DIR i386)
+  endif ()
 endif (IS_64BIT_BUILD EQUAL 1)
 
 add_subdirectory(src)

Documentation/building/cross-building.md

@@ -0,0 +1,42 @@
+Cross Compilation
+=================
+
+Through cross compilation, on Linux it is possible to build CoreCLR for ARM or ARM64.
+
+Generating the rootfs
+---------------------
+The `cross\build-rootfs.sh` script can be used to download the files needed for cross compilation. It will generate an Ubuntu 14.04 rootfs as this is what CoreCLR targets.
+
+    Usage: build-rootfs.sh [BuildArch]
+    BuildArch can be: arm, arm64
+
+This script requires a Debian based host, and the following packages installed
+
+    qemu
+    qemu-user-static
+    binfmt-support
+    debootstrap
+
+The `build-rootfs.sh` script must be run as root as it has to make some symlinks to the system, it will by default generate the rootfs in `cross\rootfs\<BuildArch>` however this can be changed by setting the `ROOTFS_DIR` environment variable.
+
+For example, to generate an ARM rootfs:
+
+    ben@ubuntu ~/git/coreclr/ $ sudo ./cross/build-rootfs.sh arm
+
+and if you wanted to generate the rootfs elsewhere:
+
+    ben@ubuntu ~/git/coreclr/ $ sudo ROOTFS_DIR=/home/ben/coreclr-cross/arm ./build-rootfs.sh arm
+
+Cross compiling CoreCLR
+-----------------------
+Once the rootfs has been generated it will be possible to cross compile CoreCLR. To cross compile CoreCLR the binutils for the target are required, for ARM this is `binutils-arm-linux-gnueabihf` and for ARM64 this is `binutils-aarch64-linux-gnu`. If `ROOTFS_DIR` was set when generating the rootfs, then it must also be set when running `build.sh`.
+
+So, without `ROOTFS_DIR`:
+
+    ben@ubuntu ~/git/coreclr/ $ ./build.sh arm debug verbose clean cross
+
+And with:
+
+    ben@ubuntu ~/git/coreclr/ $ ROOTFS_DIR=/home/ben/coreclr-cross/arm ./build.sh arm debug verbose clean cross
+
+As usual the resulting binaries will be found in `bin/Product/BuildOS.BuildArch.BuildType/`

Documentation/building/custom-dnx-instructions.md

@@ -80,7 +80,7 @@ You need to restore dependent nuget packages with the dnu tool (comes with DNX).
 
 You can now run the app, with dnx.
 
-	C:\coreclr-demo>dnx . run
+	C:\coreclr-demo>dnx run
 
 Switching to CoreCLR
 ====================
@@ -101,7 +101,7 @@ You should now have two runtimes installed. The CoreCLR one will be the default.
 You will need to repeat the steps above to run your app on CoreCLR (CoreCLR requires more NuGet packages).
 
 	C:\coreclr-demo>dnu restore
-	C:\coreclr-demo>dnx . run
+	C:\coreclr-demo>dnx run
 
 Creating a Custom DNX
 =====================
@@ -139,7 +139,7 @@ You now need to select the custom DNX as the use to 'use'. You can see the new D
 
 Try running the app again to validate that you have a working installation with the custom DNX.
 
-	C:\coreclr-demo>dnx . run
+	C:\coreclr-demo>dnx run
 
 Injecting a Custom CoreCLR into your Custom DNX
 ===============================================
@@ -159,4 +159,4 @@ You should re-generate crossgen images for your DNX to provide the best performa
 
 You should now have a working custom CoreCLR x64 DNX. Give it a try.
 
-	C:\coreclr-demo>dnx . run
+	C:\coreclr-demo>dnx run