diff --git a/CREDITS.txt b/CREDITS.txt
index 7be8dbf..5a31e80 100644
--- a/CREDITS.txt
+++ b/CREDITS.txt
@@ -8,6 +8,9 @@
 (W), PGP key ID and fingerprint (P), description (D), and snail-mail address
 (S).
 
+N: Carlo Bertolli
+D: IBM contributor to PowerPC support in CMake files and elsewhere.
+
 N: Sunita Chandrasekaran
 D: Contributor to testsuite from OpenUH
 
diff --git a/runtime/Build_With_CMake.txt b/runtime/Build_With_CMake.txt
new file mode 100644
index 0000000..fbc0f77
--- /dev/null
+++ b/runtime/Build_With_CMake.txt
@@ -0,0 +1,225 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#//                     The LLVM Compiler Infrastructure
+#//
+#// This file is dual licensed under the MIT and the University of Illinois Open
+#// Source Licenses. See LICENSE.txt for details.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+               Building libiomp5 using CMake
+               =============================
+
+   ---- Version of CMake required: v2.8.0 or above ----
+ 
+============================================
+How to call cmake initially, then repeatedly
+============================================
+- When calling cmake for the first time, all needed compiler options
+  must be specified on the command line.  After this initial call to
+  cmake, the compiler definitions must not be included for further calls
+  to cmake.  Other options can be specified on the command line multiple
+  times including all definitions in the Build options section below.
+- Example of configuring, building, reconfiguring, rebuilding:
+  $ mkdir build
+  $ cd build
+  $ cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Darch=32 ..  # Initial configuration
+  $ make all common
+  ...
+  $ make clean
+  $ cmake -Darch=32e -DCMAKE_BUILD_TYPE=Debug ..                        # Second configuration
+  $ make all common
+  ...
+  $ rm -rf *
+  $ cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Darch=32e .. # Third configuration
+  $ make all common
+- Notice in the example how the compiler definitions are only specified
+  for an empty build directory, but other Build options are used at any time.
+- The file CMakeCache.txt which is created after the first call to cmake
+  is a configuration file which holds all the values for the Build options.
+  These configuration values can be changed using a text editor to modify 
+  CMakeCache.txt as opposed to using definitions on the command line.
+- To have cmake create a particular type of build generator file simply 
+  inlude the -G <Generator name> option:
+  $ cmake -G "Unix Makefiles" ...
+  You can see a list of generators cmake supports by executing cmake with
+  no arguments and a list will be printed.
+
+=====================
+Instructions to Build
+=====================
+ $ cd libomp_top_level/ [ directory with src/ , exports/ , tools/ , etc. ]
+ $ mkdir build
+ $ cd build
+
+ [ Linux* , Mac* Libraries ]
+ $ cmake -DCMAKE_C_COMPILER=<C Compiler> -DCMAKE_CXX_COMPILER=<C++ Compiler> ..
+
+ [ Intel(R) Many Integrated Core Library (Intel(R) MIC Library) ]
+ $ cmake -DCMAKE_C_COMPILER=<C Compiler> -DCMAKE_CXX_COMPILER=<C++ Compiler> -Dos=mic -Darch=32e ..
+
+ [ Windows Libraries ]
+ $ cmake -G "Unix Makefiles" -DCMAKE_C_COMPILER=<C Compiler> -DCMAKE_CXX_COMPILER=<C++ Compiler> -DCMAKE_ASM_MASM_COMPILER=[ml | ml64] -DCMAKE_BUILD_TYPE=Release ..
+
+ $ make all common
+
+=================
+Mac* Fat Libraries
+=================
+On OS X* machines, it is possible to build universal (or fat) libraries which
+include both IA-32 architecture and Intel(R) 64 architecture objects in a
+single archive; just build the 32 and 32e libraries separately:
+ $ cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -Darch=32 ..
+ $ make
+ $ cmake -Darch=32e ..
+ $ make
+then invoke make again with a special argument as follows:
+ $ make fat
+- The fat target is only available for the arch=32e configuration.
+- The fat libraries will be put in exports/mac_32e/lib while the "thin" libraries
+  will be in exports/mac_32e/lib.thin and exports/mac_32/lib.thin
+
+================
+Compiler options
+================
+-DCMAKE_C_COMPILER=<C compiler name>
+-DCMAKE_CXX_COMPILER=<C++ compiler name>
+
+-DCMAKE_Fortran_COMPILER=<Fortran compiler name>
+Unix* systems (Optional as compiler is default):
+This option is only needed when -Dcreate_fortran_modules is true
+
+-DCMAKE_ASM_COMPILER=<Assembler name>
+This option isn't usually needed for Non-Windows* builds
+
+-DCMAKE_ASM_MASM_COMPILER=[ml | ml64 ]
+This option is Windows* Only
+
+=============
+Build options
+=============
+
+==========================
+==== Operating System ====
+==========================
+-Dos=lin|mac|win|mic
+* Operating system can be lin (Linux*), mac (Mac*), win (Windows*), or
+  mic (Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture)).
+  If not specified, cmake will try to determine your current operating system.
+
+======================
+==== Architecture ====
+======================
+-Darch=32|32e|arm|ppc64
+* Architecture can be 32 (IA-32 architecture), 32e (Intel(R) 64 architecture),
+  arm (ARM architecture), or ppc64 (PPC64 architecture).
+  This option, by default is chosen based on the
+  CMake variable CMAKE_SIZEOF_VOID_P.  If it is 8, then Intel(R) 64 architecture
+  is assumed.  If it is 4, then IA-32 architecture is assumed.  If you want to
+  use a different architecture other than x86 based architecture, you must specify
+  it when calling cmake initially using this -Darch=<arch> option or by changing 
+  the arch value via CMakeCache.txt or the CMake GUI after the initial CMake run.
+
+---- First values listed are the default value ----
+-Dlib_type=normal|profile|stubs
+Library type can be normal, profile, or stubs.
+
+-DCMAKE_BUILD_TYPE=Release|Debug|RelWithDebInfo
+Build type can be Release, Debug, or RelWithDebInfo.
+See below for interaction when -DUSE_BUILDPL_RULES is on.
+
+-Dversion=5|4
+libiomp5 version can be 5 or 4.
+
+-Domp_version=40|30
+OpenMP version can be either 40 or 30.
+
+-Dmic_arch=knc|knf
+Intel(R) MIC Architecture.  Can be 
+knf (Knights Ferry) or knc (Knights Corner).
+This value is ignored if os != mic
+  
+-Dmic_os=lin|bsd
+Operating system on Intel(R) MIC Architecture.
+Can be either bsd or lin.  This value is ignored if os != mic
+
+-Dcreate_fortran_modules=off|on
+Should the Fortran modules be created (requires Fortran compiler)
+
+-Dstats=off|on
+Should include stats-gathering code?
+
+=====================
+==== Micro tests ====
+=====================
+After the library has been built, five microtests are performed.
+Some will be skipped based upon the platform.
+These tests can be turned on (default) or off with the following options:
+-Dtest_touch=on|off     -- Should the touch test be done?
+-Dtest_relo=on|off      -- Should the position independent code test be done?
+-Dtest_execstack=on|off -- Should the stack be checked for executability?
+-Dtest_instr=on|off     -- Should the Intel(R) MIC Libraries be checked 
+                            for correct instruction set?
+-Dtest_deps=on|off      -- Should libiomp5's dependencies be checked?
+-Dtests=off|on          -- Should any of the above tests be done?
+
+============================================
+==== How to append flags to compilation ====
+============================================
+- These flags are *appended*.  They do not 
+  overwrite any of the preset flags.
+-DUSER_CPP_FLAGS=<space-separated flags>    -- Additional C Preprocessor flags
+                                               (typically additional -Ddef=val flags)
+-DUSER_C_FLAGS=<space-separated flags>      -- Additional C compiler flags
+-DUSER_CXX_FLAGS=<space-separated flags>    -- Additional C++ compiler flags
+-DUSER_ASM_FLAGS=<space-separated flags>    -- Additional assembly flags
+-DUSER_LD_FLAGS=<space-separated flags>     -- Additional linker flags
+-DUSER_LD_LIB_FLAGS=<space-separated flags> -- Additional libraries to link 
+                                               to during link phase
+-DUSER_F_FLAGS=<space-separated flags>  -- Additional Fortran compiler flags
+
+===================================
+==== Feature Based Compilation ====
+===================================
+-DUSE_BUILDPL_RULES=false|true
+Should the build imitate build.pl's build process.
+When this is true, the Unix* Release builds will build libiomp5
+with -O2 and -g flags activated (same as RelWithDebInfo). Then,
+the debug info is stripped out of the library and put into libiomp5.dbg
+This is done for interaction with Intel(R) Parallel Amplifier.
+
+-DUSE_ADAPTIVE_LOCKS=true|false       
+Should adaptive (TSX-based) locks be included?  
+These are x86 specific.  This feature is turned on by default 
+for IA-32 architecture and Intel(R) 64 architecture. 
+Otherwise, it is turned off.
+
+-DUSE_PREDEFINED_LINKER_FLAGS=true|false
+Should the predefined linker flags in CommonFlags.cmake be included
+in the link command? This is true by default and should work for
+Linux*, Mac*, and Windows*.  The --version-script flag on Unix* based
+operating systems will be included regardless.
+
+========================
+Examples usages of CMake
+========================
+---- Typical usage ----
+cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc ..
+cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ ..
+cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ..
+
+---- With Various Options ----
+cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Dos=lin -Darch=32 ..
+cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -Dos=mac -Darch=32 -DCMAKE_BUILD_TYPE=Debug ..
+cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc -DCMAKE_Fortran_COMPILER=ifort -Dtests=on -Dcreate_fortran_modules=on -DUSE_BUILDPL_RULES=on ..
+cmake -DUSER_CFLAGS='Werror' -DUSER_CPP_FLAGS='-DNEW_FEATURE=1 -DOLD_FEATURE=0' -DUSER_CXX_FLAGS='-Werror -Wsign-compare' ..
+
+---- Stubs library ----
+cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Dlib_type=stubs ..
+
+=========
+Footnotes
+=========
+[*] Other names and brands may be claimed as the property of others.
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 908e500..62c84c6 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -1,8 +1,833 @@
-project(openmp)
-cmake_minimum_required(VERSION 2.8)
+#
+#//===----------------------------------------------------------------------===//
+#//
+#//                     The LLVM Compiler Infrastructure
+#//
+#// This file is dual licensed under the MIT and the University of Illinois Open
+#// Source Licenses. See LICENSE.txt for details.
+#//
+#//===----------------------------------------------------------------------===//
+#
 
-set(VERSION 5)
-set(OMP_VERSION "201107")
-set(OMP_VERSION_NUM "40")
+################
+# CMAKE libiomp5
+cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
+project(libiomp C CXX)
 
-add_subdirectory(src)
+#########
+# GLOBALS 
+set(GLOBAL_DEBUG 0)
+
+# Add cmake directory to search for custom cmake functions
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
+
+# Set base libomp directory (directory with exports/ , src/ , tools/ , etc.)
+# The top-level CMakeLists.txt should define this variable.
+set(LIBOMP_WORK ${CMAKE_CURRENT_SOURCE_DIR})
+
+# These include files are in cmake/ subdirectory except for FindPerl which is a cmake standard module
+include(HelperFunctions)
+include(Definitions) # -D definitions when compiling 
+include(CommonFlags) # compiler, assembler, fortran, linker flags common for all compilers
+include(SourceFiles) # source files to compile 
+include(PerlFlags)   # Perl flags for generate-def.pl and expand-vars.pl
+include(FindPerl) # Standard cmake module to check for Perl
+
+####################################################################
+#                         CONFIGURATION
+#
+# * Any variable/value that is CACHE-ed can be changed after the initial run of cmake
+# through the file, CMakeCache.txt which is in the build directory.
+# * If you change any value in CMakeCache.txt, then just run cmake ..
+# and the changed will be picked up.  One can also use -DVARIABLE=VALUE
+# when calling cmake to changed configuration values.  
+# * CMAKE_C_COMPILER, CMAKE_CXX_COMPILER, CMAKE_ASM_MASM_COMPILER, CMAKE_ASM_COMPILER,
+# CMAKE_Fortran_COMPILER can only by specified on the initial run of cmake. 
+# This means you cannot specify -DCMAKE_C_COMPILER= on a subsequent run of cmake
+# in the same build directory until that build directory is emptied.
+# If you want to change the compiler, then empty the build directory and rerun cmake.
+
+# Build Configuration
+set(os_possible_values          lin mac win mic)
+set(arch_possible_values        32e 32 arm ppc64)
+set(build_type_possible_values  release debug relwithdebinfo)
+set(omp_version_possible_values 40 30)
+set(lib_type_possible_values    normal profile stubs)
+set(mic_arch_possible_values    knf knc)
+set(mic_os_possible_values      bsd lin)
+
+# Below, cmake will try and determine the operating system and architecture for you (it assumes Intel architecture)
+# These values are set in CMakeCache.txt when cmake is first run (-Dvar_name=... will take precedence)
+#  parameter  | default value             
+# ----------------------------
+# Right now, this build system considers os=lin to mean "Unix-like that is not MAC"
+if(${APPLE}) # Apple goes first because CMake considers Mac to be a Unix based operating system, while libiomp5 considers it a special case
+    set(os             mac         CACHE STRING "The operating system to build for (lin/mac/win/mic)")
+elseif(${UNIX})
+    set(os             lin         CACHE STRING "The operating system to build for (lin/mac/win/mic)")
+elseif(${WIN32})       
+    set(os             win         CACHE STRING "The operating system to build for (lin/mac/win/mic)")
+else()
+    set(os             lin         CACHE STRING "The operating system to build for (lin/mac/win/mic)")
+endif()
+
+# set to default architecture if the user did not specify an architecture explicitly
+if(NOT arch)	
+	if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "4")
+    	set(arch           32          CACHE STRING "The architecture to build for (32e/32/arm/ppc64).  32e is Intel(R) 64 architecture, 32 is IA-32 architecture")
+	else()
+    	set(arch           32e         CACHE STRING "The architecture to build for (32e/32/arm/ppc64).  32e is Intel(R) 64 architecture, 32 is IA-32 architecture")
+	endif()
+endif()
+
+set(lib_type       normal        CACHE STRING "Performance,Profiling,Stubs library (normal/profile/stubs)")
+set(version        5             CACHE STRING "Produce libguide (version 4) or libiomp5 (version 5)")
+set(omp_version    40            CACHE STRING "The OpenMP version (40/30)")
+set(mic_arch       knc           CACHE STRING "Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) (knf/knc).   Ignored if not Intel(R) MIC Architecture build.")
+set(mic_os         lin           CACHE STRING "Intel(R) MIC Architecture operating system (bsd/lin).   Ignored if not Intel(R) MIC Architecture build.")
+set(create_fortran_modules false CACHE STRING "Create Fortran module files? (requires fortran compiler)")
+
+# - These tests are little tests performed after the library is formed.
+# - The library won't be copied to the exports directory until it has passed/skipped all below tests
+# - To skip these tests, just pass -Dtests=OFF to cmake or change tests value in CMakeCache.txt to OFF after running cmake
+set(test_touch      true         CACHE BOOL   "Perform a small touch test?"                            )
+set(test_relo       true         CACHE BOOL   "Perform a relocation test for dynamic libraries?"       )
+set(test_execstack  true         CACHE BOOL   "Perform a execstack test for linux dynamic libraries?"  )
+set(test_instr      true         CACHE BOOL   "Perform an instruction test for Intel(R) MIC Architecture libraries?" )
+set(test_deps       true         CACHE BOOL   "Perform a library dependency test?"                     )
+set(tests           false        CACHE BOOL   "Perform touch, relo, execstack, instr, and deps tests?" )
+
+# - stats-gathering enables OpenMP stats where things like the number of parallel regions, clock ticks spent in
+#   particular openmp regions are recorded.
+set(stats           false         CACHE BOOL   "Stats-Gathering functionality?"                         )
+
+# User specified flags.  These are appended to the predetermined flags found in CommonFlags.cmake and ${CMAKE_C_COMPILER_ID}/*Flags.cmake (i.e., GNU/CFlags.cmake)
+set(USER_C_FLAGS      "" CACHE STRING "Appended user specified C compiler flags."             )
+set(USER_CXX_FLAGS    "" CACHE STRING "Appended user specified C++ compiler flags."           )
+set(USER_CPP_FLAGS    "" CACHE STRING "Appended user specified C preprocessor flags."         )
+set(USER_ASM_FLAGS    "" CACHE STRING "Appended user specified assembler flags."              )
+set(USER_LD_FLAGS     "" CACHE STRING "Appended user specified linker flags."                 )
+set(USER_LD_LIB_FLAGS "" CACHE STRING "Appended user specified linked libs flags. (i.e., -lm)")
+set(USER_F_FLAGS      "" CACHE STRING "Appended user specified Fortran compiler flags.  These are only used if create_fortran_modules==true."       )
+
+# - Allow three build types: Release, Debug, RelWithDebInfo (these relate to build.pl's release, debug, and diag settings respectively)
+# - default is Release (when CMAKE_BUILD_TYPE is not defined)
+# - CMAKE_BUILD_TYPE affects the -O and -g flags (CMake magically includes correct version of them on per compiler basis)
+# - typical: Release = -O3 -DNDEBUG
+#            RelWithDebInfo = -O2 -g -DNDEBUG
+#            Debug = -g
+if(CMAKE_BUILD_TYPE)
+    # CMAKE_BUILD_TYPE was defined, check for validity 
+    string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lowercase)
+    check_variable(cmake_build_type_lowercase  "${build_type_possible_values}")
+else()
+    # CMAKE_BUILD_TYPE was not defined, set default to Release
+    unset(CMAKE_BUILD_TYPE CACHE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: Release/Debug/RelWithDebInfo")
+    string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lowercase)
+    check_variable(cmake_build_type_lowercase  "${build_type_possible_values}")
+endif()
+
+# Check valid values
+check_variable(os          "${os_possible_values}"         )
+check_variable(arch        "${arch_possible_values}"       )
+check_variable(omp_version "${omp_version_possible_values}")
+check_variable(lib_type    "${lib_type_possible_values}"   )
+if("${os}" STREQUAL "mic")
+    check_variable(mic_arch "${mic_arch_possible_values}"  )
+    check_variable(mic_os   "${mic_os_possible_values}"    )
+endif()
+# Get the build number from kmp_version.c
+get_build_number("${LIBOMP_WORK}" build_number)
+
+# Getting time and date 
+# As of now, no timestamp will be created.
+set(date "No Timestamp")
+
+#################################################################
+# Set some useful flags variables for other parts of cmake to use
+# Operating System
+set(LINUX FALSE)
+set(MAC FALSE)
+set(WINDOWS FALSE)
+set(MIC FALSE)
+set(FREEBSD FALSE)
+if("${os}" STREQUAL "lin")
+    set(LINUX TRUE)
+    set(real_os lin)
+elseif("${os}" STREQUAL "mac")
+    set(MAC TRUE)
+    set(real_os mac)
+elseif("${os}" STREQUAL "win")
+    set(WINDOWS TRUE)
+    set(real_os win)
+elseif("${os}" STREQUAL "mic")
+    set(MIC TRUE)
+    set(real_os lrb)
+endif()
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
+    set(FREEBSD TRUE)
+endif()
+
+# Architecture
+set(IA32 FALSE)
+set(INTEL64 FALSE)
+set(ARM FALSE)
+set(PPC64 FALSE)
+if("${arch}" STREQUAL "32")      # IA-32 architecture
+    set(IA32 TRUE)
+elseif("${arch}" STREQUAL "32e") # Intel(R) 64 architecture
+    set(INTEL64 TRUE)
+elseif("${arch}" STREQUAL "arm") # ARM architecture
+    set(ARM TRUE)
+elseif("${arch}" STREQUAL "ppc64") # PPC64 architecture
+    set(PPC64 TRUE)
+endif()
+
+# Set some flags based on build_type
+# cmake_build_type_lowercase is based off of CMAKE_BUILD_TYPE, just put in lowercase.
+set(RELEASE_BUILD        FALSE)
+set(DEBUG_BUILD          FALSE)
+set(RELWITHDEBINFO_BUILD FALSE)
+if("${cmake_build_type_lowercase}" STREQUAL "release")
+    set(RELEASE_BUILD TRUE)
+elseif("${cmake_build_type_lowercase}" STREQUAL "debug")
+    set(DEBUG_BUILD TRUE)
+elseif("${cmake_build_type_lowercase}" STREQUAL "relwithdebinfo")
+    set(RELWITHDEBINFO_BUILD TRUE)
+endif()
+
+# Stats-gathering on or off?
+set(STATS_GATHERING FALSE)
+if("${stats}") # string "on" or "ON" is seen as boolean TRUE
+    set(STATS_GATHERING TRUE)
+endif()
+
+# Include itt notify interface? Right now, always.
+set(USE_ITT_NOTIFY TRUE)
+
+# normal, profile, stubs library.
+set(NORMAL_LIBRARY FALSE)
+set(STUBS_LIBRARY FALSE)
+set(PROFILE_LIBRARY FALSE)
+if("${lib_type}" STREQUAL "normal")
+    set(NORMAL_LIBRARY TRUE)
+elseif("${lib_type}" STREQUAL "profile")
+    set(PROFILE_LIBRARY TRUE)
+elseif("${lib_type}" STREQUAL "stubs")
+    set(STUBS_LIBRARY TRUE)
+endif()
+
+###############################################
+# Features for compilation and build in general
+
+# - Does the compiler support a 128-bit floating point data type? Default is false
+# - If a compiler does, then change it in the CMakeCache.txt file (or using the cmake GUI)
+#   or send to cmake -DCOMPILER_SUPPORTS_QUAD_PRECISION=true
+# - If COMPILER_SUPPORTS_QUAD_PRECISION is true, then a corresponding COMPILER_QUAD_TYPE must be given
+#   This is the compiler's quad-precision data type.
+# ** TODO: This isn't complete yet. Finish it. Requires changing macros in kmp_os.h **
+set(COMPILER_SUPPORTS_QUAD_PRECISION false CACHE BOOL   "*INCOMPLETE* Does the compiler support a 128-bit floating point type?")
+set(COMPILER_QUAD_TYPE               ""    CACHE STRING "*INCOMPLETE* The quad precision data type (i.e., for gcc, __float128)")
+
+# - Should the orignal build rules for builds be used? (cmake/OriginalBuildRules.cmake).  This setting is off by default.
+# - This always compiles with -g.  And if it is a release build, the debug info is stripped out via objcopy and put into libiomp5.dbg.
+set(USE_BUILDPL_RULES false CACHE BOOL "Should the build follow build.pl rules/recipes?")
+
+# - Should the build use the predefined linker flags (OS-dependent) in CommonFlags.cmake?
+# - these predefined linker flags should work for Windows, Mac, and True Linux for the most popular compilers/linkers
+set(USE_PREDEFINED_LINKER_FLAGS true CACHE BOOL "Should the build use the predefined linker flags in CommonFlags.cmake?")
+
+# - TSX based locks have __asm code which can be troublesome for some compilers.  This feature is also x86 specific.
+if({${IA32} OR ${INTEL64})
+    set(USE_ADAPTIVE_LOCKS true CACHE BOOL "Should TSX-based lock be compiled (adaptive lock in kmp_lock.cpp).  These are x86 specific.")
+else()
+    set(USE_ADAPTIVE_LOCKS false CACHE BOOL "Should TSX-based lock be compiled (adaptive lock in kmp_lock.cpp).  These are x86 specific.")
+endif()
+
+##################################
+# Error checking the configuration 
+if(${STATS_GATHERING} AND (${WINDOWS} OR ${MAC}))
+    error_say("Stats-gathering functionality is only supported on x86-Linux and Intel(R) MIC Architecture")
+endif()
+if(${STATS_GATHERING} AND NOT (${IA32} OR ${INTEL64}))
+    error_say("Stats-gathering functionality is only supported on x86-Linux and Intel(R) MIC Architecture")
+endif()
+if(${USE_ADAPTIVE_LOCKS} AND NOT(${IA32} OR ${INTEL64}))
+    error_say("Adaptive locks (TSX) functionality is only supported on x86 Architecture")
+endif()
+
+###############################################
+# - Create the suffix for the export directory
+# - Only add to suffix when not a default value
+# - Example suffix: .deb.30.s1 
+#   final export directory: exports/lin_32e.deb.30.s1/lib
+# - These suffixes imply the build is a Debug, OpenMP 3.0, Stats-Gathering version of the library
+if(NOT "${cmake_build_type_lowercase}" STREQUAL "release")
+    string(SUBSTRING "${cmake_build_type_lowercase}" 0 3 build_type_suffix)
+    set(suffix "${suffix}.${build_type_suffix}")
+endif()
+if(NOT "${omp_version}" STREQUAL "40")
+    set(suffix "${suffix}.${omp_version}")
+endif()
+if(${STATS_GATHERING})
+    set(suffix "${suffix}.s1")
+endif()
+if(${MIC})
+    if(NOT "${mic_arch}" STREQUAL "knf")
+        set(suffix "${suffix}.${mic_arch}")
+    endif()
+    if(NOT "${mic_os}" STREQUAL "bsd")
+        set(suffix "${suffix}.${mic_os}")
+    endif()
+endif()
+
+####################################
+# Setting file extensions / suffixes
+set(obj ${CMAKE_C_OUTPUT_EXTENSION}   )
+set(lib ${CMAKE_STATIC_LIBRARY_SUFFIX})
+set(dll ${CMAKE_SHARED_LIBRARY_SUFFIX})
+set(exe ${CMAKE_EXECUTABLE_SUFFIX}    )
+
+######################
+# Find perl executable
+# Perl is used to create omp.h (and other headers) along with kmp_i18n_id.inc and kmp_i18n_default.inc (see below in Rules section)
+if(NOT "${PERL_FOUND}") # variable is defined in FindPerl Standard CMake Module
+    error_say("Error: Could not find valid perl")
+endif()
+
+#########################
+# Setting directory names
+set(platform       "${real_os}_${arch}"                ) # i.e., lin_32e, mac_32
+set(build_dir      "${CMAKE_CURRENT_BINARY_DIR}"       ) # build directory (Where CMakeCache.txt is created, build files generated)
+set(src_dir        "${LIBOMP_WORK}/src"                )
+set(tools_dir      "${LIBOMP_WORK}/tools"              ) 
+set(export_dir     "${LIBOMP_WORK}/exports"            ) 
+set(export_cmn_dir "${export_dir}/common${suffix}"     ) 
+set(export_ptf_dir "${export_dir}/${platform}${suffix}")
+_export_lib_dir(${platform} export_lib_dir)  # set exports directory (relative to build_dir) i.e., ../exports/lin_32e/lib/
+                                             # or i.e., ../exports/mac_32e/lib.thin/ for mac
+if(${MAC})
+    # macs use lib.thin/ subdirectory for non-fat libraries that only contain one architecture
+    # macs use lib/ subdirectory for fat libraries that contain both IA-32 architecture and Intel(R) 64 architecture code.
+    _export_lib_fat_dir(${platform} export_lib_fat_dir)
+endif()
+set(inc_dir        "${LIBOMP_WORK}/src/include/${omp_version}")
+
+############################
+# Setting final library name
+set(lib_item "libiomp")
+if(${PROFILE_LIBRARY})
+    set(lib_item "${lib_item}prof")
+endif()
+if(${STUBS_LIBRARY})
+    set(lib_item "${lib_item}stubs")
+endif()
+set(lib_item "${lib_item}${version}")
+if(${WINDOWS})
+    set(lib_item "${lib_item}md")
+endif()
+set(lib_ext "${dll}")
+# ${lib_file} is real library name:
+# libiomp5.so    for Linux
+# libiomp5.dylib for Mac
+# libiomp5md.dll for Windows
+set(lib_file "${lib_item}${lib_ext}")
+
+########################################
+# Setting export file names (full paths)
+if(${WINDOWS})
+    set(imp_file "${lib_item}${lib}") # this is exported (libiomp5md.lib)
+    set(def_file "${lib_item}.def") # this is not exported
+    set(rc_file  "${lib_item}.rc")  # this is not exported
+    if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug" OR "${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" OR ${USE_BUILDPL_RULES})
+        set(pdb_file "${lib_file}.pdb") # this is exported if it exists (libiomp5md.dll.pdb)
+    endif()
+endif()
+set(export_lib_files  "${lib_file}" "${imp_file}" "${pdb_file}") 
+set(export_inc_files  "iomp_lib.h")
+set(export_mod_files  "omp_lib.mod" "omp_lib_kinds.mod")
+set(export_cmn_files1 "omp.h" "omp_lib.h" "omp_lib.f" "omp_lib.f90")
+set(export_cmn_files2 "iomp.h")
+add_prefix("${export_lib_dir}/"                export_lib_files)
+add_prefix("${export_ptf_dir}/include_compat/" export_inc_files)
+add_prefix("${export_ptf_dir}/include/"        export_mod_files)
+add_prefix("${export_cmn_dir}/include/"        export_cmn_files1)
+add_prefix("${export_cmn_dir}/include_compat/" export_cmn_files2)
+set(export_cmn_files "${export_cmn_files1}" "${export_cmn_files2}")
+if("${export_lib_fat_dir}")
+    set(export_lib_fat_files "${lib_file}" "${imp_file}")
+    add_prefix("${export_lib_fat_dir}/" export_lib_fat_files)
+endif()
+
+#########################
+# Getting legal type/arch
+set_legal_type(legal_type)
+set_legal_arch(legal_arch)
+
+#################################################
+# Preprocessor Definitions (cmake/Definitions.cmake)
+# Preprocessor Includes 
+# Compiler (C/C++) Flags (cmake/CommonFlags.cmake)
+# Assembler Flags (cmake/CommonFlags.cmake)
+# Fortran   Flags (cmake/CommonFlags.cmake)
+# Linker    Flags (cmake/CommonFlags.cmake)
+# Archiver  Flags (cmake/CommonFlags.cmake)
+# Helper Perl Script Flags (cmake/PerlFlags.cmake)
+# * Inside the cmake/CommonFlags.cmake file, the USER_*_FLAGS are added.
+# * Cannot use CMAKE_*_FLAGS directly because -x c++ is put in the linker command and mangles the linking phase.
+
+# preprocessor flags (-D definitions and -I includes)
+# Grab environment variable CPPFLAGS and append those to definitions
+set(include_dirs ${CMAKE_CURRENT_BINARY_DIR} ${src_dir} ${src_dir}/i18n ${inc_dir} ${src_dir}/thirdparty/ittnotify)
+include_directories(${include_dirs})
+
+# Grab assembler-dependent flags
+# CMake will look for cmake/${CMAKE_ASM_COMPILER_ID}/AsmFlags.cmake to append additional assembler flags.
+if(${WINDOWS})
+    # Windows based systems use CMAKE_ASM_MASM_COMPILER
+    # The windows assembly files are in MASM format, and they require a tool that can handle MASM syntax (ml.exe or ml64.exe typically)
+    enable_language(ASM_MASM) 
+    set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_ASM_MASM_COMPILER_ID} ${CMAKE_MODULE_PATH})
+    find_file(assembler_specific_include_file_found AsmFlags.cmake ${CMAKE_MODULE_PATH})
+    if(assembler_specific_include_file_found)
+        include(AsmFlags)
+        append_assembler_specific_asm_flags(ASM_FLAGS)
+    else()
+        warning_say("Could not find cmake/${CMAKE_ASM_MASM_COMPILER_ID}/AsmFlags.cmake: will only use default flags")
+    endif()
+else()
+    # Unix (including Mac) based systems use CMAKE_ASM_COMPILER
+    # Unix assembly files can be handled by compiler usually.
+    enable_language(ASM)
+    set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_ASM_COMPILER_ID} ${CMAKE_MODULE_PATH})
+    find_file(assembler_specific_include_file_found AsmFlags.cmake ${CMAKE_MODULE_PATH})
+    if(assembler_specific_include_file_found)
+        include(AsmFlags)
+        append_assembler_specific_asm_flags(ASM_FLAGS)
+    else()
+        warning_say("Could not find cmake/${CMAKE_ASM_COMPILER_ID}/AsmFlags.cmake: will only use default flags")
+    endif()
+endif()
+# Grab compiler-dependent flags
+# Cmake will look for cmake/${CMAKE_C_COMPILER_ID}/CFlags.cmake to append additional c, cxx, and linker flags.
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_C_COMPILER_ID} ${CMAKE_MODULE_PATH})
+find_file(compiler_specific_include_file_found CFlags.cmake ${CMAKE_MODULE_PATH})
+if(compiler_specific_include_file_found)
+    include(CFlags) # COMPILER_SUPPORTS_QUAD_PRECISION changed in here
+    append_compiler_specific_c_and_cxx_flags(C_FLAGS CXX_FLAGS)
+    append_compiler_specific_linker_flags(LD_FLAGS LD_LIB_FLAGS)
+else()
+    warning_say("Could not find cmake/${CMAKE_C_COMPILER_ID}/CFlags.cmake: will only use default flags")
+endif()
+
+# Grab all the compiler-independent flags
+append_c_and_cxx_flags_common(C_FLAGS CXX_FLAGS) 
+append_asm_flags_common(ASM_FLAGS)
+append_fort_flags_common(F_FLAGS)
+append_linker_flags_common(LD_FLAGS LD_LIB_FLAGS)
+append_archiver_flags_common(AR_FLAGS)
+append_cpp_flags(DEFINITIONS_FLAGS)
+
+# Setup the flags correctly for cmake (covert to string)
+# Pretty them up (STRIP any beginning and trailing whitespace)
+list_to_string("${DEFINITIONS_FLAGS}" DEFINITIONS_FLAGS)
+list_to_string("${C_FLAGS}"           C_FLAGS          )
+list_to_string("${CXX_FLAGS}"         CXX_FLAGS        )
+list_to_string("${ASM_FLAGS}"         ASM_FLAGS        )
+list_to_string("${LD_FLAGS}"          LD_FLAGS         )
+list_to_string("${LD_LIB_FLAGS}"      LD_LIB_FLAGS     )
+list_to_string("${AR_FLAGS}"          AR_FLAGS         ) # Windows specific for creating import library
+string(STRIP   "${DEFINITIONS_FLAGS}" DEFINITIONS_FLAGS)
+string(STRIP   "${C_FLAGS}"           C_FLAGS          )
+string(STRIP   "${CXX_FLAGS}"         CXX_FLAGS        )
+string(STRIP   "${ASM_FLAGS}"         ASM_FLAGS        )
+string(STRIP   "${LD_FLAGS}"          LD_FLAGS         )
+string(STRIP   "${LD_LIB_FLAGS}"      LD_LIB_FLAGS     )
+string(STRIP   "${AR_FLAGS}"          AR_FLAGS         ) # Windows specific for creating import library
+
+# Grab the Perl flags
+set_ev_flags(ev_flags) # expand-vars.pl flags
+set_gd_flags(gd_flags) # generate-def.pl flags (Windows only)
+set(oa_opts "--os=${real_os}" "--arch=${arch}") # sent to the perl scripts
+
+#########################################################
+# Getting correct source files (cmake/SourceFiles.cmake)
+set_c_files(lib_c_items)
+set_cpp_files(lib_cxx_items)
+set_asm_files(lib_asm_items)
+set_imp_c_files(imp_c_items) # Windows-specific
+
+###################################
+# Setting all source file variables
+set(lib_src_files "${lib_c_items}" "${lib_cxx_items}" "${lib_asm_items}")
+set(imp_src_files "${imp_c_items}")
+add_prefix("${src_dir}/" lib_src_files)
+add_prefix("${src_dir}/" imp_src_files) # Windows-specific
+add_prefix("${src_dir}/" lib_c_items  )
+add_prefix("${src_dir}/" lib_cxx_items)
+add_prefix("${src_dir}/" lib_asm_items)
+add_prefix("${src_dir}/" imp_c_items  ) # Windows-specific
+
+#####################################################################
+# Debug print outs.  Will print "variable = ${variable}" if GLOBAL_DEBUG == 1
+if(GLOBAL_DEBUG)
+    include(CMakePrintSystemInformation)
+endif()
+debug_say_var(CMAKE_ASM_COMPILE_OBJECT)
+debug_say_var(CMAKE_RC_COMPILER)
+debug_say_var(CMAKE_C_COMPILER_ID)
+debug_say_var(LIBOMP_WORK)
+debug_say_var(date)
+debug_say_var(stats)
+debug_say_var(lib_file)
+debug_say_var(export_lib_files)
+debug_say_var(DEFINITIONS_FLAGS)
+debug_say_var(C_FLAGS)
+debug_say_var(CXX_FLAGS)
+debug_say_var(ASM_FLAGS)
+debug_say_var(F_FLAGS)
+debug_say_var(LD_FLAGS)
+debug_say_var(LD_LIB_FLAGS)
+debug_say_var(AR_FLAGS)
+debug_say_var(ev_flags)
+debug_say_var(gd_flags)
+debug_say_var(oa_opts)
+debug_say_var(lib_c_items)
+debug_say_var(lib_cxx_items)
+debug_say_var(lib_asm_items)
+debug_say_var(imp_c_items)
+debug_say_var(lib_src_files)
+debug_say_var(imp_src_files)
+
+####################################################################
+#                     ---------------------                        #
+#                     --- Rules/Recipes ---                        #
+#                     ---------------------                        #
+####################################################################
+# Below, ${ldeps} always stands for "local dependencies" for the 
+# next immediate target to be created via add_custom_target() or 
+# add_custom_command()
+
+####################
+# --- Create all ---
+add_custom_target(lib ALL DEPENDS ${export_lib_files})
+add_custom_target(inc ALL DEPENDS ${export_inc_files})
+if(${create_fortran_modules})
+add_custom_target(mod ALL DEPENDS ${export_mod_files})
+endif()
+# --- Enforce the tests to be completed/skipped before copying to exports directory ---
+if(${tests})
+    if(${WINDOWS})
+        set(test-dependencies test-touch-mt/.success test-touch-md/.success test-relo/.success test-execstack/.success test-instr/.success test-deps/.success)
+    else()
+        set(test-dependencies test-touch-rt/.success test-relo/.success test-execstack/.success test-instr/.success test-deps/.success)
+    endif()
+    set_source_files_properties(${export_lib_files} PROPERTIES OBJECT_DEPENDS "${test-dependencies}")
+endif()
+
+#############################
+# --- Create Common Files ---
+add_custom_target(common DEPENDS ${export_cmn_files})
+add_custom_target(clean-common COMMAND ${CMAKE_COMMAND} -E remove -f ${export_cmn_files})
+
+##########################################
+# --- Copy files to export directories ---
+# - just a simple copy recipe which acts as an install step
+# - copies out of the src_dir into the dest_dir
+#
+# dest_dir/target : src_dir/target
+#    cp src_dir/target dest_dir/target
+macro (simple_copy_recipe target src_dir dest_dir)
+    get_source_file_property(extra_depends ${dest_dir}/${target} OBJECT_DEPENDS)
+    if("${extra_depends}" MATCHES "NOTFOUND")
+        set(extra_depends)
+    endif()
+    set(ldeps ${src_dir}/${target} "${extra_depends}")
+    if(NOT "${target}" STREQUAL "")
+        file(MAKE_DIRECTORY ${dest_dir}) # make sure destination directory exists
+        add_custom_command(
+            OUTPUT   ${dest_dir}/${target}
+            COMMAND  ${CMAKE_COMMAND} -E copy ${src_dir}/${target} ${dest_dir}/${target}
+            DEPENDS  ${ldeps}
+        )
+    endif()
+endmacro()
+# copy from build directory to final resting places in exports directory
+simple_copy_recipe("omp.h"             "${build_dir}"  "${export_cmn_dir}/include")
+simple_copy_recipe("omp_lib.h"         "${build_dir}"  "${export_cmn_dir}/include")
+simple_copy_recipe("omp_lib.f"         "${build_dir}"  "${export_cmn_dir}/include")
+simple_copy_recipe("omp_lib.f90"       "${build_dir}"  "${export_cmn_dir}/include")
+simple_copy_recipe("iomp.h"            "${build_dir}"  "${export_cmn_dir}/include_compat")
+simple_copy_recipe("${lib_file}"       "${build_dir}"  "${export_lib_dir}")
+simple_copy_recipe("${imp_file}"       "${build_dir}"  "${export_lib_dir}")
+simple_copy_recipe("${pdb_file}"       "${build_dir}"  "${export_lib_dir}")
+simple_copy_recipe("${dbg_file}"       "${build_dir}"  "${export_lib_dir}")
+simple_copy_recipe("omp_lib.mod"       "${build_dir}"  "${export_ptf_dir}/include")
+simple_copy_recipe("omp_lib_kinds.mod" "${build_dir}"  "${export_ptf_dir}/include")
+simple_copy_recipe("iomp_lib.h"        "${build_dir}"  "${export_ptf_dir}/include_compat")
+
+######################################################
+# --- Build the main library ---
+# $(lib_file) <== Main library file to create
+
+# objects depend on : .inc files and omp.h
+# This way the *.inc and omp.h are generated before any compilations take place
+add_custom_target(needed-headers DEPENDS ${build_dir}/kmp_i18n_id.inc ${build_dir}/kmp_i18n_default.inc ${build_dir}/omp.h)
+
+# For Windows, there is a definitions file (.def) and resource file (.res) created using generate-def.pl and rc.exe respectively.
+if(${WINDOWS})
+    add_custom_target(needed-windows-files DEPENDS ${build_dir}/${def_file} ${build_dir}/${rc_file})
+    list(APPEND lib_src_files ${build_dir}/${rc_file})
+    # The windows assembly files are in MASM format, and they require a tool that can handle MASM syntax (ml.exe or ml64.exe typically)
+    enable_language(ASM_MASM) 
+else()
+    # Unix assembly files can be handled by compiler.
+    enable_language(ASM)
+endif()
+
+# Remove any cmake-automatic linking of libraries by linker, This is so linux 
+# and mac don't include libstdc++ just because we compile c++ files.
+if(${USE_PREDEFINED_LINKER_FLAGS})
+    set(CMAKE_C_IMPLICIT_LINK_LIBRARIES   "")
+    set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
+    set(CMAKE_ASM_IMPLICIT_LINK_LIBRARIES "")
+endif()
+
+# --- ${lib_file} rule ---
+add_library(iomp5 SHARED ${lib_src_files})
+set_target_properties(iomp5 PROPERTIES 
+    PREFIX "" SUFFIX ""          # Take control 
+    OUTPUT_NAME "${lib_file}"    # of output name
+    LINK_FLAGS  "${LD_FLAGS}"     
+    LINKER_LANGUAGE C            # use C Compiler for linking step
+    SKIP_BUILD_RPATH true        # have Mac linker -install_name just be "-install_name libiomp5.dylib"
+)
+# Target lib (export files) depend on the library (iomp5) being built
+add_dependencies(lib iomp5)
+
+# Linking command will include libraries in LD_LIB_FLAGS
+target_link_libraries(iomp5 ${LD_LIB_FLAGS})
+
+# Create *.inc and omp.h before compiling any sources
+add_dependencies(iomp5 needed-headers)
+if(${WINDOWS})
+# Create .def and .rc file before compiling any sources
+    add_dependencies(iomp5 needed-windows-files)
+endif()
+
+# Set the compiler flags for each type of source
+set_source_files_properties(${lib_c_items} 
+                            ${imp_c_items}   PROPERTIES COMPILE_FLAGS "${C_FLAGS}"  )
+set_source_files_properties(${lib_cxx_items} PROPERTIES COMPILE_FLAGS "${CXX_FLAGS}")
+set_source_files_properties(${lib_asm_items} PROPERTIES COMPILE_FLAGS "${ASM_FLAGS}")
+# Set the -D definitions for all sources
+add_definitions(${DEFINITIONS_FLAGS})
+
+# If creating a build that imitates build.pl's rules then set USE_BUILDPL_RULES to true
+if(${USE_BUILDPL_RULES})
+    include(BuildPLRules)
+endif()
+
+######################################################
+# --- Source file specific flags ---
+# kmp_version.o : -D _KMP_BUILD_TIME="\"$(date)}\""
+set_source_files_properties(${src_dir}/kmp_version.c  PROPERTIES COMPILE_DEFINITIONS "_KMP_BUILD_TIME=\"\\\"${date}\\\"\"")
+
+# z_Linux_asm.o : -D KMP_ARCH_*
+if(${ARM})
+    set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_ARM")
+elseif(${INTEL64})
+    set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_X86_64")
+elseif(${IA32})
+    set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_X86")
+elseif(${PPC64})
+	set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_PPC64")
+endif()
+
+if(${WINDOWS})
+    set_source_files_properties(${src_dir}/thirdparty/ittnotify/ittnotify_static.c PROPERTIES COMPILE_DEFINITIONS "UNICODE")
+endif()
+
+######################################################
+# MAC specific build rules
+if(${MAC})
+    # fat library rules
+    if(${INTEL64})
+        _export_lib_fat_dir( "mac_32e" export_fat_mac_32e)
+        _export_lib_dir(     "mac_32"  export_mac_32     )
+        _export_lib_dir(     "mac_32e" export_mac_32e    )
+        file(MAKE_DIRECTORY ${export_fat_mac_32e})
+        add_custom_target(fat
+            COMMAND ${CMAKE_COMMAND} -E echo Building 32 and 32e fat libraries from ${export_mac_32}/${lib_file} and ${export_mac_32e}/${lib_file}
+            COMMAND ${CMAKE_COMMAND} -E echo Will put fat library in ${export_fat_mac_32e} directory
+            COMMAND lipo -create -output ${export_fat_mac_32e}/${lib_file} ${export_mac_32}/${lib_file} ${export_mac_32e}/${lib_file}
+        )
+    endif()
+endif()
+
+######################################################
+# Windows specific build rules
+if(${WINDOWS})
+
+    # --- Create $(imp_file) ---
+    # This file is first created in the unstripped/${lib_file} creation step.
+    # It is then "re-linked" to include kmp_import.c which prevents linking of both Visual Studio OpenMP and newly built OpenMP
+    if(NOT "${imp_file}" STREQUAL "")
+        set(generated_import_file ${lib_file}${lib})
+        add_library(iomp5imp STATIC ${generated_import_file} ${imp_src_files})
+        set_source_files_properties(${generated_import_file} PROPERTIES GENERATED TRUE EXTERNAL_OBJECT TRUE)
+        set_target_properties(iomp5imp PROPERTIES
+            PREFIX "" SUFFIX ""
+            OUTPUT_NAME "${imp_file}"
+            STATIC_LIBRARY_FLAGS "${AR_FLAGS}"
+            LINKER_LANGUAGE C
+            SKIP_BUILD_RPATH true
+        )
+        add_custom_command(TARGET iomp5imp PRE_BUILD COMMAND ${CMAKE_COMMAND} -E remove -f ${imp_file})
+        add_dependencies(iomp5imp iomp5)
+    endif()
+
+    # --- Create $(def_file) ---
+    if(NOT "${def_file}" STREQUAL "")
+        string_to_list("${gd_flags}" gd_flags)
+        add_custom_command(
+            OUTPUT  ${def_file}
+            COMMAND ${PERL_EXECUTABLE} ${tools_dir}/generate-def.pl ${gd_flags} -o ${def_file} ${src_dir}/dllexports
+            DEPENDS ${src_dir}/dllexports ${tools_dir}/generate-def.pl
+        )
+    endif()
+
+    # --- Create $(rc_file) ---
+    if(NOT "${rc_file}" STREQUAL "")
+        add_custom_command(
+            OUTPUT  ${rc_file}
+            COMMAND ${CMAKE_COMMAND} -E copy libiomp.rc ${rc_file}
+            DEPENDS libiomp.rc
+        )
+    endif()
+endif()
+
+######################################################
+# kmp_i18n_id.inc and kmp_i18n_default.inc
+set(perlcmd "${PERL_EXECUTABLE}" "${tools_dir}/message-converter.pl" "${oa_opts}" "--prefix=kmp_i18n" "--enum=kmp_i18n_id.inc" "${src_dir}/i18n/en_US.txt")
+add_custom_command(
+    OUTPUT  ${build_dir}/kmp_i18n_id.inc
+    COMMAND ${perlcmd}
+    DEPENDS ${src_dir}/i18n/en_US.txt ${tools_dir}/message-converter.pl
+)
+set(perlcmd "${PERL_EXECUTABLE}" "${tools_dir}/message-converter.pl" "${oa_opts}" "--prefix=kmp_i18n" "--default=kmp_i18n_default.inc" "${src_dir}/i18n/en_US.txt")
+add_custom_command(
+    OUTPUT  ${build_dir}/kmp_i18n_default.inc
+    COMMAND ${perlcmd}
+    DEPENDS ${src_dir}/i18n/en_US.txt ${tools_dir}/message-converter.pl
+)
+
+######################################################
+# Micro test rules for after library has been built (cmake/MicroTests.cmake)
+# - Only perform if ${tests} == true (specify when invoking: cmake -Dtests=on ...)
+if(${tests})
+    include(MicroTests)
+endif()
+
+######################################################
+# --- Create Fortran Files ---
+# omp_lib.mod
+if(${create_fortran_modules})
+    # Grab fortran-compiler-dependent flags
+    # Cmake will look for cmake/${CMAKE_Fortran_COMPILER_ID}/FortranFlags.cmake to append additional fortran flags.
+    enable_language(Fortran)
+    set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_Fortran_COMPILER_ID} ${CMAKE_MODULE_PATH})
+    find_file(fortran_specific_include_file_found FortranFlags.cmake ${CMAKE_MODULE_PATH})
+    if(fortran_specific_include_file_found)
+        include(FortranFlags)
+        append_fortran_compiler_specific_fort_flags(F_FLAGS)
+    else()
+        warning_say("Could not find cmake/${CMAKE_Fortran_COMPILER_ID}/FortranFlags.cmake: will only use default flags in CommonFlags.cmake")
+    endif()
+    set(omp_lib_f "omp_lib.f90" )
+    add_custom_command(
+        OUTPUT "omp_lib.mod"
+        COMMAND ${CMAKE_Fortran_COMPILER} -c ${F_FLAGS} ${omp_lib_f}
+        DEPENDS ${omp_lib_f}
+    )
+    add_custom_command(
+        OUTPUT "omp_lib_kinds.mod"
+        COMMAND ${CMAKE_Fortran_COMPILER} -c ${F_FLAGS} ${omp_lib_f}
+        DEPENDS ${omp_lib_f}
+    )
+    # clean omp_lib.o from build directory when "make clean" 
+    set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES omp_lib${obj})
+endif()
+
+###############################################################
+# --- Using expand-vars.pl to generate files ---
+# - 'file' is generated using expand-vars.pl and 'file'.var
+# - Any .h .f .f90 .rc files should be created with this recipe
+macro(expand_vars_recipe filename)
+    get_source_file_property(extra_ev_flags ${filename} COMPILE_DEFINITIONS)
+    if("${extra_ev_flags}" MATCHES "NOTFOUND")
+        set(extra_ev_flags)
+    else()
+        string_to_list("${extra_ev_flags}" extra_ev_flags)
+    endif()
+    find_file(${filename}_path ${filename}.var PATHS ${src_dir}/include/${omp_version} ${src_dir})
+    set(ldeps "${${filename}_path}" "${src_dir}/kmp_version.c" "${tools_dir}/expand-vars.pl")
+    set(expandvarscmd ${PERL_EXECUTABLE} ${tools_dir}/expand-vars.pl --strict ${ev_flags} ${extra_ev_flags} ${${filename}_path} ${filename})
+    if(NOT "${filename}" STREQUAL "")
+        add_custom_command(
+            OUTPUT  ${filename}
+            COMMAND ${expandvarscmd}
+            DEPENDS ${ldeps}
+        )
+    endif()
+endmacro()
+string_to_list("${ev_flags}" ev_flags)
+# omp_lib.h  : ev-flags += -D KMP_INT_PTR_KIND="int_ptr_kind()"
+set_source_files_properties(omp_lib.h PROPERTIES COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=\"int_ptr_kind()\"") 
+# iomp_lib.h : ev-flags += -D KMP_INT_PTR_KIND=$(if $(filter 32,$(arch)),4,8)
+if(${IA32}) # 32 bit archs
+    set_source_files_properties(iomp_lib.h PROPERTIES COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=4") 
+else()
+    set_source_files_properties(iomp_lib.h PROPERTIES COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=8") 
+endif()
+# libiomp.rc : ev-flags += -D KMP_FILE=$(lib_file)
+set_source_files_properties(libiomp.rc PROPERTIES COMPILE_DEFINITIONS "-D KMP_FILE=${lib_file}") 
+expand_vars_recipe(omp.h)
+expand_vars_recipe(omp_lib.h)
+expand_vars_recipe(omp_lib.f)
+expand_vars_recipe(omp_lib.f90)
+expand_vars_recipe(iomp.h)
+expand_vars_recipe(iomp_lib.h)
+expand_vars_recipe(libiomp.rc)
+
+
+####################################################################
+# Print configuration after all variables are set.
+say("")
+say("----------------------- CONFIGURATION -----------------------")
+say("Operating System   : ${os}")
+say("Architecture       : ${arch}")
+say("Build Type         : ${CMAKE_BUILD_TYPE}")
+say("OpenMP Version     : ${omp_version}")
+say("Lib Type           : ${lib_type}")
+if(${MIC})
+    say("Intel(R) MIC Architecture    : ${mic_arch}")
+    say("Intel(R) MIC Architecture OS : ${mic_os}")
+endif()
+say("Fortran Modules    : ${create_fortran_modules}")
+# will say development if all zeros
+if("${build_number}" STREQUAL "00000000")
+    set(build "development")
+else()
+    set(build "${build_number}")
+endif()
+say("Build              : ${build}")
+say("Stats-Gathering    : ${stats}")
+say("Use build.pl rules : ${USE_BUILDPL_RULES}")
+say("Adaptive locks     : ${USE_ADAPTIVE_LOCKS}")
+say("Use predefined linker flags      : ${USE_PREDEFINED_LINKER_FLAGS}")
+say("Compiler supports quad precision : ${COMPILER_SUPPORTS_QUAD_PRECISION}")
+say("-------------------------------------------------------------")
+say("")
+
diff --git a/runtime/CMakeLists.txt.old b/runtime/CMakeLists.txt.old
new file mode 100644
index 0000000..908e500
--- /dev/null
+++ b/runtime/CMakeLists.txt.old
@@ -0,0 +1,8 @@
+project(openmp)
+cmake_minimum_required(VERSION 2.8)
+
+set(VERSION 5)
+set(OMP_VERSION "201107")
+set(OMP_VERSION_NUM "40")
+
+add_subdirectory(src)
diff --git a/runtime/cmake/BuildPLRules.cmake b/runtime/cmake/BuildPLRules.cmake
new file mode 100644
index 0000000..8db0f2f
--- /dev/null
+++ b/runtime/cmake/BuildPLRules.cmake
@@ -0,0 +1,100 @@
+###############################################################################
+# This file contains additional build rules that correspond to build.pl's rules
+# Building libiomp5.dbg is linux only, Windows will build libiomp5md.dll.pdb
+#
+#                        ######### BUILD DEPENDENCIES ##########
+#
+#        exports/.../libiomp5.so                        exports/.../libiomp5.dbg
+#        [copy]  |                                                 | [copy]
+#                |                                                 |
+#           ./libiomp5.so                                     ./libiomp5.dbg
+#    [copy]    /  OR  \____________ [copy]                         | [copy]
+#             /                    \                               |
+#    ./unstripped/libiomp5.so   ./stripped/libiomp5.so   ./unstripped/libiomp5.dbg
+#           /                                \                /
+#          / [linking]                        \[strip]       /[strip and store]
+#         /                                    \            /
+#     ${objs} (maybe compiled with -g)     ./unstripped/libiomp5.so (library with debug info in it)
+#                                                    |
+#                                                    | [linking]
+#                                                    |
+#                                                 ${objs} (always compiled with -g)
+#
+# For icc Linux builds, we always include debugging information via -g and create libiomp5.dbg 
+# so that Intel(R) Parallel Amplifier can use the .dbg file.
+# For icc Windows builds, we always include debugging information via -Zi and create libiomp5.pdb
+# in a fashion similar to libiomp5.dbg
+# For icc Mac builds, we don't bother with the debug info.
+
+# We build library in unstripped directory
+file(MAKE_DIRECTORY ${build_dir}/unstripped)
+
+# Only build the .dbg file for Release builds
+# Debug and RelWithDebInfo builds should not create a .dbg file.  
+# The debug info should remain in the library file.
+if(${LINUX} AND ${RELEASE_BUILD})
+    set(dbg_file ${lib_item}.dbg)
+endif()
+
+################################
+# --- Create $(lib_file).dbg ---
+if(NOT "${dbg_file}" STREQUAL "")
+    # if a ${dbg_file} file is going to be created, then 
+    file(MAKE_DIRECTORY ${build_dir}/stripped)
+
+    # ./${lib_file} : stripped/${lib_file}
+    #     copy stripped/${lib_file} ./${lib_file}
+    simple_copy_recipe("${lib_file}"   "${build_dir}/stripped"   "${build_dir}")
+
+    # stripped/${lib_file} : unstripped/${lib_file} ./${dbg_file}
+    #     objcopy --strip-debug unstripped/${lib_file} stripped/${lib_file}.tmp
+    #     objcopy --add-gnu-debuglink=${dbg_file} stripped/${lib_file}.tmp stripped/${lib_file}
+    add_custom_command(
+        OUTPUT  ${build_dir}/stripped/${lib_file}
+        COMMAND ${CMAKE_OBJCOPY} --strip-debug ${build_dir}/unstripped/${lib_file} ${build_dir}/stripped/${lib_file}.tmp
+        COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=${dbg_file} ${build_dir}/stripped/${lib_file}.tmp ${build_dir}/stripped/${lib_file}
+        DEPENDS "${build_dir}/${dbg_file}"
+    )
+
+    # ./${dbg_file} : unstripped/${dbg_file}
+    #     copy unstripped/${dbg_file} ./${dbg_file}
+    simple_copy_recipe("${dbg_file}"   "${build_dir}/unstripped" "${build_dir}")
+
+    # unstripped/${dbg_file} : unstripped/${lib_file}
+    #     objcopy --only-keep-debug unstripped/${lib_file} unstripped/${dbg_file}
+    add_custom_command(
+        OUTPUT  ${build_dir}/unstripped/${dbg_file}
+        COMMAND ${CMAKE_OBJCOPY} --only-keep-debug ${build_dir}/unstripped/${lib_file} ${build_dir}/unstripped/${dbg_file} 
+        DEPENDS iomp5
+    )
+    
+else()
+
+    # ./${lib_file} : unstripped/${lib_file}
+    #      copy unstripped/${lib_file} ./${lib_file}
+    simple_copy_recipe("${lib_file}"   "${build_dir}/unstripped"  "${build_dir}")
+endif()
+
+# Windows specific command to move around debug info files post-build
+if(NOT "${pdb_file}" STREQUAL "" AND ${RELEASE_BUILD})
+    add_custom_command(TARGET iomp5 POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E rename ${pdb_file} ${pdb_file}.nonstripped
+        COMMAND ${CMAKE_COMMAND} -E rename ${pdb_file}.stripped ${pdb_file}
+    )
+endif()
+
+# Have icc build libiomp5 in unstripped directory
+set_target_properties(iomp5 PROPERTIES 
+    LIBRARY_OUTPUT_DIRECTORY "${build_dir}/unstripped" 
+    RUNTIME_OUTPUT_DIRECTORY "${build_dir}/unstripped"
+    ARCHIVE_OUTPUT_DIRECTORY "${build_dir}"
+)
+
+# Always use RelWithDebInfo flags for Release builds when using the build.pl's build rules (use -g -O2 instead of just -O3)
+# The debug info is then stripped out at the end of the build and put into libiomp5.dbg for Linux
+if(${RELEASE_BUILD} AND NOT ${MAC})
+    set(CMAKE_C_FLAGS_RELEASE   ${CMAKE_C_FLAGS_RELWITHDEBINFO}  )
+    set(CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
+    set(CMAKE_ASM_FLAGS_RELEASE ${CMAKE_ASM_FLAGS_RELWITHDEBINFO})
+endif()
+
diff --git a/runtime/cmake/Clang/AsmFlags.cmake b/runtime/cmake/Clang/AsmFlags.cmake
new file mode 100644
index 0000000..b23e6b9
--- /dev/null
+++ b/runtime/cmake/Clang/AsmFlags.cmake
@@ -0,0 +1,16 @@
+# This file holds Clang (clang/clang++) specific compiler dependent flags
+# The flag types are:
+#   1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+    set(local_asm_flags)
+    append_asm_flags("-x assembler-with-cpp") # Assembly file that needs to be preprocessed
+    if(${IA32})
+        append_asm_flags("-m32") # Generate 32 bit IA-32 architecture code 
+        append_asm_flags("-msse2") # Allow use of Streaming SIMD Instructions
+    endif()
+    set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/Clang/CFlags.cmake b/runtime/cmake/Clang/CFlags.cmake
new file mode 100644
index 0000000..54e1809
--- /dev/null
+++ b/runtime/cmake/Clang/CFlags.cmake
@@ -0,0 +1,38 @@
+# This file holds Clang (clang/clang++) specific compiler dependent flags
+# The flag types are:
+#   1) C/C++ Compiler flags
+#   2) Linker flags
+
+#########################################################
+# C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+    set(local_c_flags)
+    set(local_cxx_flags)
+    append_c_and_cxx_flags("-std=c++0x") # Enables support for many C++11 (formerly known as C++0x) features. The following are the most recently added features:
+    append_c_and_cxx_flags("-fno-exceptions") # Exception handling table generation is disabled.
+    append_c_and_cxx_flags("-x c++") # Compile C files as C++ files
+    if(${IA32})
+        append_c_and_cxx_flags("-m32") # Generate 32 bit IA-32 architecture code
+        append_c_and_cxx_flags("-msse2") # Allow use of Streaming SIMD Instructions
+    elseif(${ARM})
+        append_c_and_cxx_flags("-marm") # Target the ARM architecture
+    endif()
+    append_c_and_cxx_flags("-Wno-unused-value") # Don't warn about unused values
+    append_c_and_cxx_flags("-Wno-switch") # Don't warn about switch statements that don't cover entire range of values
+    set(${input_c_flags}   ${${input_c_flags}}   "${local_c_flags}" PARENT_SCOPE)
+    set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+    set(local_ld_flags)
+    set(local_ld_flags_libs)
+    if(${IA32})
+        append_linker_flags("-m32")
+        append_linker_flags("-msse2")
+    endif()
+    set(${input_ld_flags}      ${${input_ld_flags}}      "${local_ld_flags}"       PARENT_SCOPE)
+    set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}"  PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/CommonFlags.cmake b/runtime/cmake/CommonFlags.cmake
new file mode 100644
index 0000000..301a3c4
--- /dev/null
+++ b/runtime/cmake/CommonFlags.cmake
@@ -0,0 +1,133 @@
+# This file holds the common flags independent of compiler
+# The flag types are: 
+#   1) Assembly flags          (append_asm_flags_common)
+#   2) C/C++ Compiler flags    (append_c_and_cxx_flags_common)
+#   3) Fortran Compiler flags  (append_fort_flags_common)
+#   4) Linker flags            (append_linker_flags_common)
+#   5) Archiver flags          (append_archiver_flags_common)
+
+# These append_* macros all append to the corresponding list variable holding the flags.
+macro(append_c_flags new_flag)
+    list(APPEND local_c_flags    "${new_flag}")
+endmacro()
+
+macro(append_cxx_flags new_flag)
+    list(APPEND local_cxx_flags  "${new_flag}")
+endmacro()
+
+macro(append_c_and_cxx_flags new_flag)
+    append_c_flags("${new_flag}")
+    append_cxx_flags("${new_flag}")
+endmacro()
+
+macro(append_asm_flags new_flag)
+    list(APPEND local_asm_flags  "${new_flag}")
+endmacro()
+
+macro(append_fort_flags new_flag)
+    list(APPEND local_fort_flags "${new_flag}")
+endmacro()
+
+# The difference between linker_flags and linker_flags_libs is linker_flags_libs
+# is put at the end of the linker command where linking libraries should be done.
+macro(append_linker_flags new_flag)
+    list(APPEND local_ld_flags   "${new_flag}")
+endmacro()
+
+macro(append_linker_flags_library new_flag)
+    list(APPEND local_ld_flags_libs "${new_flag}")
+endmacro()
+
+macro(append_archiver_flags new_flag)
+    list(APPEND local_ar_flags   "${new_flag}")
+endmacro()
+
+#########################################################
+# Global Assembly flags
+function(append_asm_flags_common input_asm_flags)
+    set(local_asm_flags)
+    set(${input_asm_flags} "${${input_asm_flags}}" "${local_asm_flags}" "${USER_ASM_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Global C/C++ Compiler flags
+function(append_c_and_cxx_flags_common input_c_flags input_cxx_flags)
+    set(local_c_flags)
+    set(local_cxx_flags)
+    set(${input_c_flags}   "${${input_c_flags}}"   "${local_c_flags}"   "${USER_C_FLAGS}"   PARENT_SCOPE)
+    set(${input_cxx_flags} "${${input_cxx_flags}}" "${local_cxx_flags}" "${USER_CXX_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Global Fortran Compiler flags (for creating .mod files)
+function(append_fort_flags_common input_fort_flags)
+    set(local_fort_flags)
+    set(${input_fort_flags} "${${input_fort_flags}}" "${local_fort_flags}" "${USER_F_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Linker flags
+function(append_linker_flags_common input_ld_flags input_ld_flags_libs)
+    set(local_ld_flags)
+    set(local_ld_flags_libs)
+
+    #################################
+    # Windows linker flags
+    if(${WINDOWS}) 
+
+    ##################
+    # MAC linker flags
+    elseif(${MAC})
+        if(${USE_PREDEFINED_LINKER_FLAGS})
+            append_linker_flags("-single_module")
+            append_linker_flags("-current_version ${version}.0")
+            append_linker_flags("-compatibility_version ${version}.0")
+        endif()
+    #####################################################################################
+    # Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) linker flags
+    elseif(${MIC})
+        if(${USE_PREDEFINED_LINKER_FLAGS})
+            append_linker_flags("-Wl,-x")
+            append_linker_flags("-Wl,--warn-shared-textrel") #  Warn if the linker adds a DT_TEXTREL to a shared object.
+            append_linker_flags("-Wl,--as-needed")
+            append_linker_flags("-Wl,--version-script=${src_dir}/exports_so.txt") # Use exports_so.txt as version script to create versioned symbols for ELF libraries
+            if(NOT ${STUBS_LIBRARY})
+                append_linker_flags_library("-pthread") # link in pthread library
+                append_linker_flags_library("-ldl") # link in libdl (dynamic loader library)
+            endif()
+            if(${STATS_GATHERING})
+                append_linker_flags_library("-Wl,-lstdc++") # link in standard c++ library (stats-gathering needs it)
+            endif()
+        endif()
+    #########################
+    # Unix based linker flags
+    else()
+        # For now, always include --version-script flag on Unix systems.
+        append_linker_flags("-Wl,--version-script=${src_dir}/exports_so.txt") # Use exports_so.txt as version script to create versioned symbols for ELF libraries
+        if(${USE_PREDEFINED_LINKER_FLAGS})
+            append_linker_flags("-Wl,-z,noexecstack") #  Marks the object as not requiring executable stack.
+            append_linker_flags("-Wl,--as-needed")    #  Only adds library dependencies as they are needed. (if libiomp5 actually uses a function from the library, then add it)
+            if(NOT ${STUBS_LIBRARY})
+                append_linker_flags("-Wl,--warn-shared-textrel") #  Warn if the linker adds a DT_TEXTREL to a shared object.
+                append_linker_flags("-Wl,-fini=__kmp_internal_end_fini") # When creating an ELF executable or shared object, call NAME when the 
+                                                                         # executable or shared object is unloaded, by setting DT_FINI to the 
+                                                                         # address of the function.  By default, the linker uses "_fini" as the function to call.
+                append_linker_flags_library("-pthread") # link pthread library
+                if(NOT ${FREEBSD})
+                    append_linker_flags_library("-Wl,-ldl") # link in libdl (dynamic loader library)
+                endif()
+            endif()
+        endif() # if(${USE_PREDEFINED_LINKER_FLAGS})
+    endif() # if(${OPERATING_SYSTEM}) ...
+
+    set(${input_ld_flags}      "${${input_ld_flags}}"      "${local_ld_flags}"      "${USER_LD_FLAGS}"     PARENT_SCOPE)
+    set(${input_ld_flags_libs} "${${input_ld_flags_libs}}" "${local_ld_flags_libs}" "${USER_LD_LIB_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Archiver Flags
+function(append_archiver_flags_common input_ar_flags)
+    set(local_ar_flags)
+    set(${input_ar_flags} "${${input_ar_flags}}" "${local_ar_flags}" PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/Definitions.cmake b/runtime/cmake/Definitions.cmake
new file mode 100644
index 0000000..bdd11ab
--- /dev/null
+++ b/runtime/cmake/Definitions.cmake
@@ -0,0 +1,138 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#//                     The LLVM Compiler Infrastructure
+#//
+#// This file is dual licensed under the MIT and the University of Illinois Open
+#// Source Licenses. See LICENSE.txt for details.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+# void append_definitions(string new_flag);
+# - appends new_flag to cpp_flags list
+macro(append_definitions new_flag)
+    list(APPEND local_cpp_flags "${new_flag}")
+endmacro()
+
+function(append_cpp_flags input_cpp_flags)
+    set(local_cpp_flags)
+
+    append_definitions("-D USE_ITT_BUILD")
+    append_definitions("-D KMP_ARCH_STR=\"\\\\\"${legal_arch}\\\\\"\"")
+    append_definitions("-D BUILD_I8")
+    append_definitions("-D KMP_LIBRARY_FILE=\\\\\"${lib_file}\\\\\"") # yes... you need 5 backslashes...
+    append_definitions("-D KMP_VERSION_MAJOR=${version}")
+    
+    # customize to 128 bytes for ppc64
+    if(${PPC64})
+    	append_definitions("-D CACHE_LINE=128")
+    else()
+    	append_definitions("-D CACHE_LINE=64")
+    endif()
+    
+    append_definitions("-D KMP_ADJUST_BLOCKTIME=1")
+    append_definitions("-D BUILD_PARALLEL_ORDERED")
+    append_definitions("-D KMP_ASM_INTRINS")
+    if(${USE_ITT_NOTIFY})
+        append_definitions("-D USE_ITT_NOTIFY=1")
+    else()
+        append_definitions("-D USE_ITT_NOTIFY=0")
+        append_definitions("-D INTEL_NO_ITTNOTIFY_API")
+    endif()
+    append_definitions("-D INTEL_ITTNOTIFY_PREFIX=__kmp_itt_")
+
+    #####################
+    # Windows definitions
+    if(${WINDOWS})
+        append_definitions("-D _CRT_SECURE_NO_WARNINGS")
+        append_definitions("-D _CRT_SECURE_NO_DEPRECATE")
+        append_definitions("-D _WINDOWS")
+        append_definitions("-D _WINNT")
+        append_definitions("-D _WIN32_WINNT=0x0501")
+        append_definitions("-D KMP_WIN_CDECL")
+        append_definitions("-D _USRDLL")
+        if(${DEBUG_BUILD})
+            append_definitions("-D _ITERATOR_DEBUG_LEVEL=0")
+        endif()
+    else() # Other than windows... (Unix based systems, Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture), and Mac)
+        append_definitions("-D _GNU_SOURCE")
+        append_definitions("-D _REENTRANT")
+        append_definitions("-D BUILD_TV")
+        append_definitions("-D USE_CBLKDATA")
+        if(NOT "${version}" STREQUAL "4")
+            append_definitions("-D KMP_GOMP_COMPAT")
+        endif()
+    endif()
+
+    #######################################
+    # Intel(R) MIC Architecture definitions
+    if(${MIC})
+        append_definitions("-D KMP_TDATA_GTID")
+    else() # Other than Intel(R) MIC Architecture...
+        append_definitions("-D USE_LOAD_BALANCE")
+    endif()
+
+    ##################
+    # Unix definitions
+    if(${LINUX})
+        append_definitions("-D KMP_TDATA_GTID")
+    endif()
+
+    ##################################
+    # Other conditional definitions
+    append_definitions("-D KMP_USE_ASSERT")
+    append_definitions("-D GUIDEDLL_EXPORTS") 
+    if(${STUBS_LIBRARY}) 
+        append_definitions("-D KMP_STUB") 
+    endif()
+    if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD}) 
+        append_definitions("-D KMP_DEBUG") 
+    endif()
+    if(${DEBUG_BUILD})
+        append_definitions("-D _DEBUG")
+        append_definitions("-D BUILD_DEBUG")
+    endif()
+    if(${STATS_GATHERING})
+        append_definitions("-D KMP_STATS_ENABLED=1")
+    else()
+        append_definitions("-D KMP_STATS_ENABLED=0")
+    endif()
+
+    # OpenMP version flags
+    set(have_omp_50 0)
+    set(have_omp_41 0)
+    set(have_omp_40 0)
+    set(have_omp_30 0)
+    if(${omp_version} EQUAL 50 OR ${omp_version} GREATER 50)
+        set(have_omp_50 1)
+    endif()
+    if(${omp_version} EQUAL 41 OR ${omp_version} GREATER 41)
+        set(have_omp_41 1)
+    endif()
+    if(${omp_version} EQUAL 40 OR ${omp_version} GREATER 40)
+        set(have_omp_40 1)
+    endif()
+    if(${omp_version} EQUAL 30 OR ${omp_version} GREATER 30)
+        set(have_omp_30 1)
+    endif()
+    append_definitions("-D OMP_50_ENABLED=${have_omp_50}")
+    append_definitions("-D OMP_41_ENABLED=${have_omp_41}")
+    append_definitions("-D OMP_40_ENABLED=${have_omp_40}")
+    append_definitions("-D OMP_30_ENABLED=${have_omp_30}")
+
+    # Architectural definitions
+    if(${INTEL64} OR ${IA32})
+        if(${USE_ADAPTIVE_LOCKS})
+            append_definitions("-D KMP_USE_ADAPTIVE_LOCKS=1")
+        else()
+            append_definitions("-D KMP_USE_ADAPTIVE_LOCKS=0")
+        endif()
+        append_definitions("-D KMP_DEBUG_ADAPTIVE_LOCKS=0")
+    else()
+        append_definitions("-D KMP_USE_ADAPTIVE_LOCKS=0")
+        append_definitions("-D KMP_DEBUG_ADAPTIVE_LOCKS=0")
+    endif()
+    set(${input_cpp_flags} "${${input_cpp_flags}}" "${local_cpp_flags}" "${USER_CPP_FLAGS}" "$ENV{CPPFLAGS}" PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/GNU/AsmFlags.cmake b/runtime/cmake/GNU/AsmFlags.cmake
new file mode 100644
index 0000000..91fccb0
--- /dev/null
+++ b/runtime/cmake/GNU/AsmFlags.cmake
@@ -0,0 +1,16 @@
+# This file holds GNU (gcc/g++) specific compiler dependent flags
+# The flag types are:
+#   1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+    set(local_asm_flags)
+    append_asm_flags("-x assembler-with-cpp") # Assembly file that needs to be preprocessed
+    if(${IA32})
+        append_asm_flags("-m32") # Generate 32 bit IA-32 architecture code 
+        append_asm_flags("-msse2") # Allow use of Streaming SIMD Instructions
+    endif()
+    set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/GNU/CFlags.cmake b/runtime/cmake/GNU/CFlags.cmake
new file mode 100644
index 0000000..88654cc
--- /dev/null
+++ b/runtime/cmake/GNU/CFlags.cmake
@@ -0,0 +1,45 @@
+# This file holds GNU (gcc/g++) specific compiler dependent flags
+# The flag types are:
+#   2) C/C++ Compiler flags
+#   4) Linker flags
+unset(COMPILER_SUPPORTS_QUAD_PRECISION CACHE)
+set(COMPILER_SUPPORTS_QUAD_PRECISION true CACHE BOOL "Does the compiler support a 128-bit floating point type?")
+set(COMPILER_QUAD_TYPE __float128)
+
+#########################################################
+# C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+    set(local_c_flags)
+    set(local_cxx_flags)
+    append_c_and_cxx_flags("-std=c++0x") # Enables support for many C++11 (formerly known as C++0x) features. The following are the most recently added features:
+    append_c_and_cxx_flags("-fno-exceptions") # Exception handling table generation is disabled.
+    append_c_and_cxx_flags("-x c++") # Compile C files as C++ files
+    if(${IA32})
+        append_c_and_cxx_flags("-m32") # Generate 32 bit IA-32 architecture code
+        append_c_and_cxx_flags("-msse2") # Allow use of Streaming SIMD Instructions
+    elseif(${ARM})
+        append_c_and_cxx_flags("-marm") # Target the ARM architecture
+    endif()
+    set(${input_c_flags} ${${input_c_flags}} "${local_c_flags}" PARENT_SCOPE)
+    set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+    set(local_ld_flags)
+    set(local_ld_flags_libs)
+    if(${WINDOWS})
+    elseif(${MAC})
+    elseif(${MIC})
+    else()
+        append_linker_flags("-static-libgcc") # Causes libgcc to be linked in statically
+    endif()
+    if(${IA32})
+        append_linker_flags("-m32")
+        append_linker_flags("-msse2")
+    endif()
+    set(${input_ld_flags}      ${${input_ld_flags}}      "${local_ld_flags}"       PARENT_SCOPE)
+    set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}"  PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/GNU/FortranFlags.cmake b/runtime/cmake/GNU/FortranFlags.cmake
new file mode 100644
index 0000000..2a479b2
--- /dev/null
+++ b/runtime/cmake/GNU/FortranFlags.cmake
@@ -0,0 +1,14 @@
+# This file holds GNU (gcc/g++) specific compiler dependent flags
+# The flag types are:
+#   1) Fortran Compiler flags
+
+#########################################################
+# Fortran Compiler flags (for creating .mod files)
+function(append_fortran_compiler_specific_fort_flags input_fort_flags)
+    set(local_fort_flags)
+    if(${IA32})
+        append_fort_flags("-m32")
+        append_fort_flags("-msse2")
+    endif()
+    set(${input_fort_flags} ${${input_fort_flags}} "${local_fort_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/runtime/cmake/HelperFunctions.cmake b/runtime/cmake/HelperFunctions.cmake
new file mode 100644
index 0000000..88e309b
--- /dev/null
+++ b/runtime/cmake/HelperFunctions.cmake
@@ -0,0 +1,256 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#//                     The LLVM Compiler Infrastructure
+#//
+#// This file is dual licensed under the MIT and the University of Illinois Open
+#// Source Licenses. See LICENSE.txt for details.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+####################################### FUNCTIONS/MACROS ###########################################
+# It should be noted that in cmake, functions can only be used on a single line with the return value
+# stored in a parameter you send to the function.  There isn't a true return value.  So technically, 
+# all functions would have a C/C++ prototype of:
+# void function_name(parameter1, parameter2, ...);
+#  
+# If you want a return value, you have to use a parameter so the function prototype would be:
+# void function_name(input_parameter1, input_parameter2, ...,  return_value)
+# ##################
+
+# void say(string message_to_user);
+# - prints out message_to_user
+macro(say message_to_user)
+    message("${message_to_user}")
+endmacro()
+
+# void warning_say(string message_to_user);
+# - prints out message_to_user with a warning
+macro(warning_say message_to_user)
+    message(WARNING "${message_to_user}")
+endmacro()
+
+# void error_say(string message_to_user);
+# - prints out message_to_user with an error and exits cmake
+macro(error_say message_to_user)
+    message(FATAL_ERROR "${message_to_user}")
+endmacro()
+
+# void debug_say(string message_to_developer);
+# - prints out message when GLOBAL_DEBUG == 1 (for debugging cmake build)
+macro(debug_say message_to_developer)
+    if(${GLOBAL_DEBUG} STREQUAL "1")
+        say("DEBUG: ${message_to_developer}")
+    endif()
+endmacro()
+
+# void debug_say_var(variable var);
+# - prints the variable name and its value (for debugging cmake build)
+macro(debug_say_var var)
+    if(${GLOBAL_DEBUG} STREQUAL "1")
+        say("DEBUG: Variable: ${var} = ${${var}} ")
+    endif()
+endmacro()
+
+# void set_legal_arch(string* return_arch_string);
+# - returns (through return_arch_string) the formal architecture 
+#   string or warns user of unknown architecture
+function(set_legal_arch return_arch_string)
+    if(${IA32}) 
+        set(${return_arch_string} "IA-32" PARENT_SCOPE)
+    elseif(${INTEL64})
+        set(${return_arch_string} "Intel(R) 64" PARENT_SCOPE)
+    elseif(${MIC})
+        set(${return_arch_string} "Intel(R) Many Integrated Core Architecture" PARENT_SCOPE)
+    elseif(${arch} STREQUAL "l1")
+        set(${return_arch_string} "L1OM" PARENT_SCOPE)
+    elseif(${ARM})
+        set(${return_arch_string} "ARM" PARENT_SCOPE)
+	elseif(${PPC64})
+	    set(${return_arch_string} "PPC64" PARENT_SCOPE)
+    else()
+        warning_say("set_legal_arch(): Warning: Unknown architecture...")
+    endif()
+endfunction()
+
+# void check_variable(string var, string var_name, list<string>values_list);
+# - runs through values_list checking if ${var} == values_list[i] for any i.
+# - if the var is found, then just print it out
+# - if the var is not found, then warn user
+function(check_variable var values_list)
+    set(valid_flag 0)
+    foreach(value IN LISTS values_list)
+        if("${${var}}" STREQUAL "${value}")
+            set(valid_flag 1)
+            set(the_value "${value}")
+        endif()
+    endforeach()
+    if(${valid_flag} EQUAL 0)
+        error_say("check_variable(): ${var} = ${${var}} is unknown")
+    endif()
+endfunction()
+
+# void _export_lib_dir(string export_dir, string platform, string suffix, string* return_value);
+# - basically a special case for mac platforms where it adds '.thin' to the output lib directory
+function(_export_lib_dir pltfrm return_value)
+    if(${MAC})
+        set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib.thin" PARENT_SCOPE)
+    else()
+        set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib" PARENT_SCOPE)
+    endif()
+endfunction()
+
+# void _export_lib_fat_dir(string export_dir, string platform, string suffix, string* return_value);
+# - another mac specialty case for fat libraries.
+# - this sets export_lib_fat_dir in the MAIN part of CMakeLists.txt
+function(_export_lib_fat_dir pltfrm return_value)
+    set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib" PARENT_SCOPE)
+endfunction()
+
+# void get_build_number(string src_dir, string* return_build_number);
+# - grab the eight digit build number (or 00000000) from kmp_version.c
+function(get_build_number src_dir return_build_number)
+    # sets file_lines_list to a list of all lines in kmp_version.c
+    file(STRINGS "${src_dir}/src/kmp_version.c" file_lines_list)
+
+    # runs through each line in kmp_version.c
+    foreach(line IN LISTS file_lines_list)
+        # if the line begins with "#define KMP_VERSION_BUILD" then we take not of the build number
+        string(REGEX MATCH "^[ \t]*#define[ \t]+KMP_VERSION_BUILD" valid "${line}")
+        if(NOT "${valid}" STREQUAL "") # if we matched "#define KMP_VERSION_BUILD", then grab the build number
+            string(REGEX REPLACE "^[ \t]*#define[ \t]+KMP_VERSION_BUILD[ \t]+([0-9]+)" "\\1"
+                   build_number "${line}"
+            )
+        endif()
+    endforeach()
+    set(${return_build_number} "${build_number}" PARENT_SCOPE) # return build number
+endfunction()
+
+# void set_legal_type(string* return_legal_type);
+# - set the legal type name Performance/Profiling/Stub
+function(set_legal_type return_legal_type)
+    if(${NORMAL_LIBRARY})
+        set(${return_legal_type} "Performance" PARENT_SCOPE)
+    elseif(${PROFILE_LIBRARY})
+        set(${return_legal_type} "Profiling" PARENT_SCOPE)
+    elseif(${STUBS_LIBRARY})
+        set(${return_legal_type} "Stub" PARENT_SCOPE)
+    endif()
+endfunction()
+
+# void set_mac_os_new(bool* return_mac_os_new);
+# - sets the return_mac_os_new variable to true or false based on macosx version
+# - no real "cmakey" way to do this.  Have to call execute_process()
+function(set_mac_os_new return_mac_os_new)
+    execute_process(COMMAND "sw_vers" "-productVersion" OUTPUT_VARIABLE mac_osx_version)
+    if("${mac_osx_version}" VERSION_GREATER "10.6")
+        set(${return_mac_os_new} TRUE PARENT_SCOPE)
+    else()
+        set(${return_mac_os_new} FALSE PARENT_SCOPE)
+    endif()
+endfunction()
+
+# void add_prefix(string prefix, list<string>* list_of_items);
+# - returns list_of_items with prefix prepended to all items
+# - original list is modified
+function(add_prefix prefix list_of_items)
+    set(local_list "")
+    foreach(item IN LISTS "${list_of_items}")
+        if(NOT "${item}" STREQUAL "")
+            list(APPEND local_list "${prefix}${item}")
+        endif()
+    endforeach()
+    set(${list_of_items} "${local_list}" PARENT_SCOPE)
+endfunction()
+
+# void add_suffix(string suffix, list<string>* list_of_items);
+# - returns list_of_items with suffix appended to all items
+# - original list is modified
+function(add_suffix suffix list_of_items)
+    set(local_list "")
+    foreach(item IN LISTS "${list_of_items}")
+        if(NOT "${item}" STREQUAL "")
+            list(APPEND local_list "${item}${suffix}")
+        endif()
+    endforeach()
+    set(${list_of_items} "${local_list}" PARENT_SCOPE)
+endfunction()
+
+# void strip_suffix(list<string> list_of_items, list<string>* return_list);
+# - returns a new list with suffix stripped (i.e., foo.c => foo)
+# - list_of_items is not modified, return_list is modified
+function(strip_suffix list_of_items return_list)
+    set(local_list "")
+    foreach(item IN LISTS "${list_of_items}")
+        if(NOT "${item}" STREQUAL "")
+            get_filename_component(filename "${item}" NAME_WE)
+            list(APPEND local_list "${filename}")
+        endif()
+    endforeach()
+    set(${return_list} "${local_list}" PARENT_SCOPE)
+endfunction()
+
+# void list_to_string(list<string> list_of_things, string* return_string);
+# - converts a list to a space separated string
+function(list_to_string list_of_things return_string)
+    string(REPLACE ";" " " output_variable "${list_of_things}")
+    set(${return_string} "${output_variable}" PARENT_SCOPE)
+endfunction()
+
+# void string_to_list(string str, list<string>* return_list);
+# - converts a string to a semicolon separated list
+# - what it really does is just string_replace all running whitespace to a semicolon
+# - in cmake, a list is strings separated by semicolons: i.e., list of four items, list = "item1;item2;item3;item4"
+function(string_to_list str return_list)
+    set(outstr)
+    string(REGEX REPLACE "[ \t]+" ";" outstr "${str}")
+    set(${return_list} "${outstr}" PARENT_SCOPE) 
+endfunction()
+
+# void get_date(string* return_date);
+# - returns the current date "yyyy-mm-dd hh:mm:ss UTC"
+# - this function alone causes the need for CMake v2.8.11 (TIMESTAMP)
+#function(get_date return_date)
+#    string(TIMESTAMP local_date "%Y-%m-%d %H:%M:%S UTC" UTC)
+#    set(${return_date} ${local_date} PARENT_SCOPE)
+#endfunction()
+
+# void find_a_program(string program_name, list<string> extra_paths, bool fail_on_not_found, string return_variable_name);
+# - returns the full path of a program_name
+# - first looks in the list of extra_paths
+# - if not found in extra_paths, then look through system path
+# - errors out if fail_on_not_found == true and cmake could not find program_name.
+function(find_a_program program_name extra_paths fail_on_not_found return_variable_name)
+    # first try to find the program in the extra_paths
+    find_program(${return_variable_name} "${program_name}" PATHS "${extra_paths}" DOC "Path to ${program_name}" NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
+    if("${${return_variable_name}}" MATCHES NOTFOUND)
+        # if no extra_paths, or couldn't find it, then look in system $PATH
+        find_program(${return_variable_name} "${program_name}" DOC "Path to ${program_name}")
+        if("${${return_variable_name}}" MATCHES NOTFOUND AND ${fail_on_not_found})
+            error_say("Error: Could not find program: ${program_name}")
+        endif()
+    endif()
+
+    if(NOT "${${return_variable_name}}" MATCHES NOTFOUND)
+        say("-- Found ${program_name}: ${${return_variable_name}}")
+    endif()
+
+    set(${return_variable_name} ${${return_variable_name}} PARENT_SCOPE)
+endfunction()
+
+# WINDOWS SPECIFIC 
+# void replace_md_with_mt(string flags_var)
+# - This macro replaces the /MD compiler flags (Windows specific) with /MT compiler flags
+# - This does nothing if no /MD flags were replaced.
+macro(replace_md_with_mt flags_var)
+    set(flags_var_name  ${flags_var}) # i.e., CMAKE_C_FLAGS_RELEASE
+    set(flags_var_value ${${flags_var}}) # i.e., "/MD /O2 ..."
+    string(REPLACE /MD /MT temp_out "${flags_var_value}")
+    string(COMPARE NOTEQUAL "${temp_out}" "${flags_var_value}" something_was_replaced)
+    if("${something_was_replaced}")
+        unset(${flags_var_name} CACHE)
+        set(${flags_var_name} ${temp_out} CACHE STRING "Replaced /MD with /MT compiler flags")
+    endif()
+endmacro()
+
diff --git a/runtime/cmake/Intel/AsmFlags.cmake b/runtime/cmake/Intel/AsmFlags.cmake
new file mode 100644
index 0000000..59d22d9
--- /dev/null
+++ b/runtime/cmake/Intel/AsmFlags.cmake
@@ -0,0 +1,31 @@
+# This file holds Intel(R) C Compiler / Intel(R) C++ Compiler / Intel(R) Fortran Compiler (icc/icpc/icl.exe/ifort) dependent flags
+# The flag types are:
+#   1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+    set(local_asm_flags)
+    append_asm_flags("-x assembler-with-cpp") # Assembly file that needs to be preprocessed
+    if(${IA32})
+        append_asm_flags("-safeseh") # Registers exception handlers for safe exception handling.
+        append_asm_flags("-coff") # Generates common object file format (COFF) type of object module. 
+                                  # Generally required for Win32 assembly language development.
+        append_asm_flags("-D _M_IA32")
+    elseif(${INTEL64})
+        append_asm_flags("-D _M_AMD64")
+    endif()
+    if(${MIC})
+        append_asm_flags("-mmic") # Build Intel(R) MIC Architecture native code
+    endif()
+    if(${WINDOWS})
+        # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+        # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+        # replace_md_with_mt() is in HelperFunctions.cmake
+        replace_md_with_mt(CMAKE_ASM_MASM_FLAGS)
+        replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELEASE)
+        replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELWITHDEBINFO)
+        replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_DEBUG)
+    endif()
+    set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/runtime/cmake/Intel/CFlags.cmake b/runtime/cmake/Intel/CFlags.cmake
new file mode 100644
index 0000000..2122e29
--- /dev/null
+++ b/runtime/cmake/Intel/CFlags.cmake
@@ -0,0 +1,148 @@
+# This file holds Intel(R) C Compiler / Intel(R) C++ Compiler / Intel(R) Fortran Compiler (icc/icpc/icl.exe/ifort) dependent flags
+# The flag types are:
+#   2) C/C++ Compiler flags
+#   4) Linker flags
+
+# icc has a 128-bit floating point type called _Quad.  Always compile with 128-bit floating point if it exists.
+unset(COMPILER_SUPPORTS_QUAD_PRECISION CACHE)
+set(COMPILER_SUPPORTS_QUAD_PRECISION true CACHE BOOL "Does the compiler support a 128-bit floating point type?")
+set(COMPILER_QUAD_TYPE _Quad)
+
+#########################################################
+# icc C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+    set(local_c_flags)
+    set(local_cxx_flags)
+    if(${WINDOWS})
+        
+        append_c_flags("-TP") # Tells the compiler to process a file as a C++ source file.
+        append_cxx_flags("-EHsc") # Enable C++ exception handling.
+        append_c_and_cxx_flags("-nologo") # Turn off tool banner.
+        append_c_and_cxx_flags("-W3") # Enables diagnostics for remarks, warnings, and errors. 
+                                      # Additional warnings are also enabled above level 2 warnings.
+        append_c_and_cxx_flags("-WX") # Change all Warnings to Errors
+        append_c_and_cxx_flags("-GS") # Lets you control the threshold at which the stack checking routine is called or not called.
+        append_c_and_cxx_flags("-Qoption,cpp,--extended_float_types") # Enabled _Quad type.
+        if(${IA32})
+           append_c_and_cxx_flags("-arch:ia32") # Tells the compiler which features it may target (ia32)
+           append_c_and_cxx_flags("-Oy-") # equivalent to -fno-omit-frame-pointer
+        endif()
+        append_c_and_cxx_flags("-Qlong_double") # enable long double
+        append_c_and_cxx_flags("-Qdiag-disable:177") # Disable warning: "... declared but never referenced"
+        if(${IA32})
+            append_c_and_cxx_flags("-Qsafeseh") # Registers exception handlers for safe exception handling.
+        endif()
+        if(${RELEASE_BUILD} OR ${RELWITHDEBINFO_BUILD})
+            append_c_and_cxx_flags("-Qinline-min-size=1") # Specifies the upper limit for the size of what the inliner considers to be a small routine.
+        else()
+            append_c_and_cxx_flags("-Od") # Disables all optimizations.
+            append_c_and_cxx_flags("-RTC1") # Enables run-time checks of the stack frame, and enables run-time checks for unintialized variables.
+            append_c_and_cxx_flags("-MTd") # Tells the linker to search for unresolved references in a multithreaded, static run-time library.
+        endif()
+    else()
+        append_c_and_cxx_flags("-Wsign-compare") # warn on sign comparisons
+        append_c_and_cxx_flags("-Werror") # Changes all warnings to errors.
+        append_c_and_cxx_flags("-Qoption,cpp,--extended_float_types") # Enabled _Quad type.
+        append_c_and_cxx_flags("-fno-exceptions") # Exception handling table generation is disabled.
+        append_c_and_cxx_flags("-x c++") # Compile C files as C++ files
+        if(${MIC})
+            append_c_and_cxx_flags("-mmic") # Build Intel(R) MIC Architecture native code
+            append_c_and_cxx_flags("-ftls-model=initial-exec") # Changes the thread local storage (TLS) model. Generates a restrictive, optimized TLS code. 
+                                                               # To use this setting, the thread-local variables accessed must be defined in one of the 
+                                                               # modules available to the program.
+            append_c_and_cxx_flags("-opt-streaming-stores never") # Disables generation of streaming stores for optimization.
+            append_c_and_cxx_flags("-sox") # Tells the compiler to save the compilation options and version number 
+                                           # in the executable file. It also lets you choose whether to include 
+                                           # lists of certain functions.
+        elseif(${LINUX})
+            append_c_and_cxx_flags("-Werror") # Changes all warnings to errors.
+            append_c_and_cxx_flags("-sox") 
+            if(${IA32})
+                append_c_and_cxx_flags("-falign-stack=maintain-16-byte") # Tells the compiler the stack alignment to use on entry to routines.
+                append_c_and_cxx_flags("-mia32")  # Tells the compiler which features it may target (ia32)
+            endif()
+        endif()
+    endif()
+    # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+    # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+    # replace_md_with_mt() is in HelperFunctions.cmake
+    if(${WINDOWS})
+        replace_md_with_mt(CMAKE_C_FLAGS)
+        replace_md_with_mt(CMAKE_C_FLAGS_RELEASE)
+        replace_md_with_mt(CMAKE_C_FLAGS_RELWITHDEBINFO)
+        replace_md_with_mt(CMAKE_C_FLAGS_DEBUG)
+        replace_md_with_mt(CMAKE_CXX_FLAGS)
+        replace_md_with_mt(CMAKE_CXX_FLAGS_RELEASE)
+        replace_md_with_mt(CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+        replace_md_with_mt(CMAKE_CXX_FLAGS_DEBUG)
+    endif()
+    set(${input_c_flags}   ${${input_c_flags}}   "${local_c_flags}" PARENT_SCOPE)
+    set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# icc Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+    set(local_ld_flags)
+    set(local_ld_flags_libs)
+    if(${WINDOWS})
+        # Have icc use link.exe directly when Windows
+        set(CMAKE_C_CREATE_SHARED_LIBRARY "link.exe /out:<TARGET> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES>" PARENT_SCOPE)
+        set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "Linker Flags" FORCE)
+        append_linker_flags("-nologo") # Turn off tool banner.
+        append_linker_flags("-dll") 
+        append_linker_flags("-WX:NO")
+        append_linker_flags("-incremental:no")
+        append_linker_flags("-version:${version}.0")
+        append_linker_flags("-NXCompat")
+        append_linker_flags("-DynamicBase") # This option modifies the header of an executable to indicate 
+                                               # whether the application should be randomly rebased at load time.
+        if(${IA32})
+            append_linker_flags("-machine:i386")
+            append_linker_flags("-safeseh")
+        elseif(${INTEL64})
+            append_linker_flags("-machine:amd64")
+        endif()
+        if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
+            if(NOT "${pdb_file}" STREQUAL "")
+                append_linker_flags("-debug")
+                append_linker_flags("-pdb:${pdb_file}")
+            endif()
+        else()
+            if(NOT "${pdb_file}" STREQUAL "")
+                append_linker_flags("-debug")
+                append_linker_flags("-pdb:${pdb_file}")
+                append_linker_flags("-pdbstripped:${pdb_file}.stripped")
+            endif()
+        endif()
+        if(NOT "${imp_file}" STREQUAL "")
+            append_linker_flags("-implib:${lib_file}${lib}")
+        endif()
+        if(NOT "${def_file}" STREQUAL "")
+            append_linker_flags("-def:${def_file}")
+        endif()
+    elseif(${MAC})
+        append_linker_flags("-no-intel-extensions")
+        if(NOT ${STUBS_LIBRARY})
+            append_linker_flags_library("-pthread") # link in pthread library
+            append_linker_flags_library("-ldl") # link in libdl (dynamic loader library)
+        endif()
+        if(${STATS_GATHERING})
+            append_linker_flags_library("-Wl,-lstdc++") # link in standard c++ library (stats-gathering needs it)
+        endif()
+    elseif(${MIC})
+        append_linker_flags("-mmic") # enable MIC linking
+        append_linker_flags("-static-intel") # Causes Intel-provided libraries to be linked in statically. 
+        append_linker_flags("-no-intel-extensions") # Enables or disables all Intel C and Intel C++ language extensions.
+    else()
+        append_linker_flags("-static-intel") # Causes Intel-provided libraries to be linked in statically.
+        append_linker_flags("-Werror") # Warnings become errors
+        if(${IA32})
+            append_linker_flags_library("-lirc_pic") # link in libirc_pic
+        endif()
+    endif()
+
+    set(${input_ld_flags}      ${${input_ld_flags}}      "${local_ld_flags}"       PARENT_SCOPE)
+    set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}"  PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/Intel/FortranFlags.cmake b/runtime/cmake/Intel/FortranFlags.cmake
new file mode 100644
index 0000000..9279a88
--- /dev/null
+++ b/runtime/cmake/Intel/FortranFlags.cmake
@@ -0,0 +1,29 @@
+# This file holds Intel(R) C Compiler / Intel(R) C++ Compiler / Intel(R) Fortran Compiler (icc/icpc/icl.exe/ifort) dependent flags
+# The flag types are:
+#   1) Fortran Compiler flags
+
+#########################################################
+# icc Fortran Compiler flags (for creating .mod files)
+function(append_fortran_compiler_specific_fort_flags input_fort_flags)
+    set(local_fort_flags)
+    #set(CMAKE_Fortran_FLAGS      "$ENV{FFLAGS}"   CACHE STRING "Fortran flags"  FORCE)
+    #set(CMAKE_Fortran_FLAGS_RELEASE          ""   CACHE STRING "Fortran flags"  FORCE)
+    #set(CMAKE_Fortran_FLAGS_DEBUG            ""   CACHE STRING "Fortran flags"  FORCE)
+    #set(CMAKE_Fortran_FLAGS_RELWITHDEBINFO   ""   CACHE STRING "Fortran flags"  FORCE)
+    if(${WINDOWS})
+        append_fort_flags("-Qdiag-disable:177,5082")
+        append_fort_flags("-Qsox")
+        append_fort_flags("-nologo")
+        append_fort_flags("-GS")
+        append_fort_flags("-DynamicBase")
+        append_fort_flags("-Zi")
+    else()
+        if(${MIC})
+            append_fort_flags("-mmic")
+        endif()
+        if(NOT ${MAC})
+            append_fort_flags("-sox")
+        endif()
+    endif()
+    set(${input_fort_flags} ${${input_fort_flags}} "${local_fort_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/runtime/cmake/MSVC/AsmFlags.cmake b/runtime/cmake/MSVC/AsmFlags.cmake
new file mode 100644
index 0000000..dcc8302
--- /dev/null
+++ b/runtime/cmake/MSVC/AsmFlags.cmake
@@ -0,0 +1,26 @@
+# This file holds Microsoft Visual Studio dependent flags
+# The flag types are:
+#   1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+    set(local_asm_flags)
+    append_asm_flags("-nologo") # Turn off tool banner.
+    if(${IA32})
+        append_asm_flags("-safeseh") # Registers exception handlers for safe exception handling.
+        append_asm_flags("-coff") # Generates common object file format (COFF) type of object module. 
+                                  # Generally required for Win32 assembly language development.
+        append_asm_flags("-D _M_IA32")
+    elseif(${INTEL64})
+        append_asm_flags("-D _M_AMD64")
+    endif()
+    # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+    # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+    # replace_md_with_mt() is in HelperFunctions.cmake
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELEASE)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELWITHDEBINFO)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_DEBUG)
+    set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/runtime/cmake/MSVC/CFlags.cmake b/runtime/cmake/MSVC/CFlags.cmake
new file mode 100644
index 0000000..b76147a
--- /dev/null
+++ b/runtime/cmake/MSVC/CFlags.cmake
@@ -0,0 +1,64 @@
+# This file holds Microsoft Visual Studio dependent flags
+# The flag types are:
+#   1) C/C++ Compiler flags
+#   2) Fortran Compiler flags
+
+#########################################################
+# Visual Studio C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+    set(local_c_flags)
+    set(local_cxx_flags)
+    append_c_flags("-TP") # Tells the compiler to process a file as a C++ source file.
+    append_cxx_flags("-EHsc") # Enable C++ exception handling.
+    append_c_and_cxx_flags("-W3") # Enables diagnostics for remarks, warnings, and errors. 
+                                  # Additional warnings are also enabled above level 2 warnings.
+    append_c_and_cxx_flags("-GS") # Lets you control the threshold at which the stack checking routine is called or not called.
+    if(${IA32})
+        append_c_and_cxx_flags("-arch:ia32") # Tells the compiler which features it may target (ia32)
+        append_c_and_cxx_flags("-Oy-") # equivalent to -fno-omit-frame-pointer
+    endif()
+    # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+    # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+    # replace_md_with_mt() is in HelperFunctions.cmake
+    replace_md_with_mt(CMAKE_C_FLAGS)
+    replace_md_with_mt(CMAKE_C_FLAGS_RELEASE)
+    replace_md_with_mt(CMAKE_C_FLAGS_RELWITHDEBINFO)
+    replace_md_with_mt(CMAKE_C_FLAGS_DEBUG)
+    replace_md_with_mt(CMAKE_CXX_FLAGS)
+    replace_md_with_mt(CMAKE_CXX_FLAGS_RELEASE)
+    replace_md_with_mt(CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    replace_md_with_mt(CMAKE_CXX_FLAGS_DEBUG)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELEASE)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELWITHDEBINFO)
+    replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_DEBUG)
+    set(${input_c_flags}   ${${input_c_flags}}   "${local_c_flags}" PARENT_SCOPE)
+    set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Visual Studio Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+    set(local_ld_flags)
+    set(local_ld_flags_libs)
+    append_linker_flags("-WX:NO")
+    append_linker_flags("-version:${version}.0")
+    append_linker_flags("-NXCompat")
+    append_linker_flags("-DynamicBase") # This option modifies the header of an executable to indicate 
+                                           # whether the application should be randomly rebased at load time.
+    if(${IA32})
+        append_linker_flags("-machine:i386")
+        append_linker_flags("-safeseh")
+    elseif(${INTEL64})
+        append_linker_flags("-machine:amd64")
+    endif()
+    if(NOT "${def_file}" STREQUAL "")
+        append_linker_flags("-def:${def_file}")
+    endif()
+    # Have Visual Studio use link.exe directly
+    #set(CMAKE_C_CREATE_SHARED_LIBRARY "link.exe /out:<TARGET> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES>" PARENT_SCOPE)
+    #set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDLFAGS}" CACHE STRING "Linker Flags" FORCE)
+    set(${input_ld_flags}      ${${input_ld_flags}}      "${local_ld_flags}"       PARENT_SCOPE)
+    set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}"  PARENT_SCOPE)
+endfunction()
+
diff --git a/runtime/cmake/MicroTests.cmake b/runtime/cmake/MicroTests.cmake
new file mode 100644
index 0000000..50beb59
--- /dev/null
+++ b/runtime/cmake/MicroTests.cmake
@@ -0,0 +1,277 @@
+######################################################
+# MICRO TESTS
+# The following micro-tests are small tests to perform on 
+# the library just created in ${build_dir}/, there are currently
+# five micro-tests: 
+# (1) test-touch 
+#    - Compile and run a small program using newly created libiomp5 library
+#    - Fails if test-touch.c does not compile or if test-touch.c does not run after compilation
+#    - Program dependencies: gcc or g++, grep, bourne shell
+#    - Available for all Linux,Mac,Windows builds.  Not availble on Intel(R) MIC Architecture builds.
+# (2) test-relo
+#    - Tests dynamic libraries for position-dependent code (can not have any position dependent code)
+#    - Fails if TEXTREL is in output of readelf -d libiomp5.so command
+#    - Program dependencies: readelf, grep, bourne shell
+#    - Available for Linux, Intel(R) MIC Architecture dynamic library builds. Not available otherwise.
+# (3) test-execstack 
+#    - Tests if stack is executable
+#    - Fails if stack is executable. Should only be readable and writable. Not exectuable.
+#    - Program dependencies: perl, readelf
+#    - Available for Linux dynamic library builds. Not available otherwise.
+# (4) test-instr (Intel(R) MIC Architecutre only) 
+#    - Tests Intel(R) MIC Architecture libraries for valid instruction set
+#    - Fails if finds invalid instruction for Intel(R) MIC Architecture (wasn't compiled with correct flags)
+#    - Program dependencies: perl, objdump 
+#    - Available for Intel(R) MIC Architecture builds. Not available otherwise.
+# (5) test-deps      
+#    - Tests newly created libiomp5 for library dependencies
+#    - Fails if sees a dependence not listed in td_exp variable below
+#    - Program dependencies: perl, (linux)readelf, (mac)otool[64], (windows)link.exe
+#    - Available for Linux,Mac,Windows, Intel(R) MIC Architecture dynamic builds and Windows static builds. Not available otherwise.
+#
+# All tests can be turned off by including -Dtests=off when calling cmake
+# An individual test can be turned off by issuing something like -Dtest_touch=off when calling cmake
+
+# test-touch
+if(NOT ${MIC} AND ${test_touch} AND ${tests})
+    if(${WINDOWS})
+        set(do_test_touch_mt TRUE)
+        if(${do_test_touch_mt})
+            set(test_touch_items ${test_touch_items} test-touch-md test-touch-mt)
+        else()
+            set(test_touch_items ${test_touch_items} test-touch-md)
+        endif()
+    else()
+        set(test_touch_items ${test_touch_items} test-touch-rt)
+    endif()
+    set(regular_test_touch_items "${test_touch_items}")
+    add_suffix("/.success"  regular_test_touch_items)
+    # test-touch : ${test_touch_items}/.success
+    set(ldeps "${regular_test_touch_items}")
+    add_custom_target( test-touch DEPENDS ${ldeps})
+
+    if(${WINDOWS})
+        # pick test-touch compiler
+        set(tt-c cl)
+        # test-touch compilation flags
+        list(APPEND tt-c-flags -nologo)
+        if(${RELEASE_BUILD} OR ${RELWITHDEBINFO_BUILD})
+            list(APPEND tt-c-flags-mt -MT)
+            list(APPEND tt-c-flags-md -MD)
+        else()
+            list(APPEND tt-c-flags-mt -MTd)
+            list(APPEND tt-c-flags-md -MDd)
+        endif()
+        list(APPEND tt-libs ${build_dir}/${imp_file})
+        list(APPEND tt-ld-flags -link -nodefaultlib:oldnames)
+        if(${IA32})
+            list(APPEND tt-ld-flags -safeseh)
+        endif()
+        list(APPEND tt-ld-flags-v -verbose)
+    else() # (Unix based systems, Intel(R) MIC Architecture, and Mac)
+        # pick test-touch compiler
+        if(${STD_CPP_LIB})
+            set(tt-c ${CMAKE_CXX_COMPILER})
+        else()
+            set(tt-c ${CMAKE_C_COMPILER})
+        endif()
+        # test-touch compilation flags
+        if(${LINUX})
+            list(APPEND tt-c-flags -pthread)
+        endif()
+        if(${IA32})
+            list(APPEND tt-c-flags -m32)
+        elseif(${INTEL64})
+            list(APPEND tt-c-flags -m64)
+        endif()
+        list(APPEND tt-libs ${build_dir}/${lib_file})
+        if(${MAC})
+            list(APPEND tt-ld-flags-v -Wl,-t)
+            set(tt-env "DYLD_LIBRARY_PATH=.:$ENV{DYLD_LIBRARY_PATH}")
+        else()
+            list(APPEND tt-ld-flags-v -Wl,--verbose)
+            set(tt-env LD_LIBRARY_PATH=".:${build_dir}:$ENV{LD_LIBRARY_PATH}")
+        endif()
+    endif()
+    list(APPEND tt-c-flags "${tt-c-flags-rt}")
+    list(APPEND tt-env "KMP_VERSION=1")
+
+    macro(test_touch_recipe test_touch_dir)
+        file(MAKE_DIRECTORY ${build_dir}/${test_touch_dir})
+        set(ldeps ${src_dir}/test-touch.c ${build_dir}/${lib_file})
+        set(tt-exe-file ${test_touch_dir}/test-touch${exe})
+        if(${WINDOWS})
+            # ****** list(APPEND tt-c-flags -Fo$(dir $@)test-touch${obj} -Fe$(dir $@)test-touch${exe}) *******
+            set(tt-c-flags-out -Fo${test_touch_dir}/test-touch${obj} -Fe${test_touch_dir}/test-touch${exe})
+            list(APPEND ldeps ${build_dir}/${imp_file})
+        else()
+            # ****** list(APPEND tt-c-flags -o $(dir $@)test-touch${exe}) ********
+            set(tt-c-flags-out -o ${test_touch_dir}/test-touch${exe})
+        endif()
+        add_custom_command(
+            OUTPUT  ${test_touch_dir}/.success
+            COMMAND ${CMAKE_COMMAND} -E remove -f ${test_touch_dir}/*
+            COMMAND ${tt-c} ${tt-c-flags-out} ${tt-c-flags} ${src_dir}/test-touch.c ${tt-libs} ${tt-ld-flags}
+            COMMAND ${CMAKE_COMMAND} -E remove -f ${tt-exe-file}
+            COMMAND ${tt-c} ${tt-c-flags-out} ${tt-c-flags} ${src_dir}/test-touch.c ${tt-libs} ${tt-ld-flags} ${tt-ld-flags-v} > ${test_touch_dir}/build.log 2>&1
+            COMMAND ${tt-env} ${tt-exe-file}
+            #COMMAND grep -i -e \"[^_]libirc\" ${test_touch_dir}/build.log > ${test_touch_dir}/libirc.log \; [ $$? -eq 1 ]
+            COMMAND ${CMAKE_COMMAND} -E touch ${test_touch_dir}/.success
+            DEPENDS ${ldeps}
+        )
+    endmacro()
+    if(${WINDOWS})
+        test_touch_recipe(test-touch-mt)
+        test_touch_recipe(test-touch-md)
+    else()
+        test_touch_recipe(test-touch-rt)
+    endif()
+else()
+    add_custom_target(test-touch DEPENDS test-touch/.success)
+    macro(test_touch_recipe_skip test_touch_dir)
+        if(${tests} AND ${test_touch})
+            set(test_touch_message 'test-touch is not available for the Intel(R) MIC Architecture.  Will not perform it.')
+        else()
+            set(test_touch_message "test-touch is turned off.  Will not perform it.")
+        endif()
+        add_custom_command(
+            OUTPUT ${test_touch_dir}/.success
+            COMMAND ${CMAKE_COMMAND} -E echo ${test_touch_message}
+        )
+    endmacro()
+    test_touch_recipe_skip(test-touch-rt)
+    test_touch_recipe_skip(test-touch-mt)
+    test_touch_recipe_skip(test-touch-md)
+endif()
+
+# test-relo 
+add_custom_target(test-relo DEPENDS test-relo/.success)
+if((${LINUX} OR ${MIC}) AND ${test_relo} AND ${tests})
+    file(MAKE_DIRECTORY ${build_dir}/test-relo)
+    add_custom_command(
+        OUTPUT  test-relo/.success
+        COMMAND readelf -d ${build_dir}/${lib_file} > test-relo/readelf.log
+        COMMAND grep -e TEXTREL test-relo/readelf.log \; [ $$? -eq 1 ]
+        COMMAND ${CMAKE_COMMAND} -E touch test-relo/.success
+        DEPENDS ${build_dir}/${lib_file}
+    )
+else()
+    if(${tests} AND ${test_relo})
+        set(test_relo_message 'test-relo is only available for dynamic library on Linux or Intel(R) MIC Architecture.  Will not perform it.')
+    else()
+        set(test_relo_message "test-relo is turned off.  Will not perform it.")
+    endif()
+    add_custom_command(
+        OUTPUT  test-relo/.success
+        COMMAND ${CMAKE_COMMAND} -E echo ${test_relo_message}
+    )
+endif()
+
+# test-execstack
+add_custom_target(test-execstack DEPENDS test-execstack/.success)
+if(${LINUX} AND ${test_execstack} AND ${tests})
+    file(MAKE_DIRECTORY ${build_dir}/test-execstack)
+    add_custom_command(
+        OUTPUT  test-execstack/.success
+        COMMAND ${PERL_EXECUTABLE} ${tools_dir}/check-execstack.pl ${build_dir}/${lib_file}
+        COMMAND ${CMAKE_COMMAND} -E touch test-execstack/.success
+        DEPENDS ${build_dir}/${lib_file}
+    )
+else()
+    if(${tests} AND ${test_execstack})
+        set(test_execstack_message "test-execstack is only available for dynamic library on Linux.  Will not perform it.")
+    else()
+        set(test_execstack_message "test-execstack is turned off.  Will not perform it.")
+    endif()
+    add_custom_command(
+        OUTPUT  test-execstack/.success
+        COMMAND ${CMAKE_COMMAND} -E echo ${test_execstack_message}
+    )
+endif()
+
+# test-instr
+add_custom_target(test-instr DEPENDS test-instr/.success)
+if(${MIC} AND ${test_instr} AND ${tests})
+    file(MAKE_DIRECTORY ${build_dir}/test-instr)
+    add_custom_command(
+        OUTPUT  test-instr/.success
+        COMMAND ${PERL_EXECUTABLE} ${tools_dir}/check-instruction-set.pl ${oa_opts} --show --mic-arch=${mic_arch} --mic-os=${mic_os} ${build_dir}/${lib_file}
+        COMMAND ${CMAKE_COMMAND} -E touch test-instr/.success
+        DEPENDS ${build_dir}/${lib_file} ${tools_dir}/check-instruction-set.pl
+    )
+else()
+    if(${tests} AND ${test_instr})
+        set(test_instr_message 'test-instr is only available for Intel(R) MIC Architecture libraries.  Will not perform it.')
+    else()
+        set(test_instr_message "test-instr is turned off.  Will not perform it.")
+    endif()
+    add_custom_command(
+        OUTPUT  test-instr/.success
+        COMMAND ${CMAKE_COMMAND} -E echo ${test_instr_message}
+    )
+endif()
+
+# test-deps
+add_custom_target(test-deps DEPENDS test-deps/.success)
+if(${test_deps} AND ${tests})
+    set(td_exp)
+    if(${FREEBSD})
+        set(td_exp libc.so.7 libthr.so.3 libunwind.so.5)
+    elseif(${LINUX})
+        set(td_exp libdl.so.2,libgcc_s.so.1)
+        if(NOT ${IA32} AND NOT ${INTEL64})
+            set(td_exp ${td_exp},libffi.so.6,libffi.so.5)
+        endif()
+        if(${IA32})
+            set(td_exp ${td_exp},libc.so.6,ld-linux.so.2)  
+        elseif(${INTEL64})
+            set(td_exp ${td_exp},libc.so.6,ld-linux-x86-64.so.2)  
+        elseif(${ARM})
+            set(td_exp ${td_exp},libc.so.6,ld-linux-armhf.so.3)  
+        endif()
+        if(${STD_CPP_LIB})
+            set(td_exp ${td_exp},libstdc++.so.6)
+        endif()
+        if(NOT ${STUBS_LIBRARY})
+            set(td_exp ${td_exp},libpthread.so.0)
+        endif()
+    elseif(${MIC})
+        if("${mic_os}" STREQUAL "lin")
+            set(td_exp libc.so.6,libpthread.so.0,libdl.so.2)
+            if(${STD_CPP_LIB})
+                set(td_exp ${td_exp},libstdc++.so.6)
+            endif()
+            if("${mic_arch}" STREQUAL "knf")
+                set(td_exp ${td_exp},ld-linux-l1om.so.2,libgcc_s.so.1)
+            elseif("${mic_arch}" STREQUAL "knc")
+                set(td_exp ${td_exp},ld-linux-k1om.so.2)
+            endif()
+        elseif("${mic_os}" STREQUAL "bsd")
+            set(td_exp libc.so.7,libthr.so.3,libunwind.so.5)
+        endif()
+    elseif(${MAC})
+        set(td_exp /usr/lib/libSystem.B.dylib)
+    elseif(${WINDOWS})
+        set(td_exp kernel32.dll)
+    endif()
+
+    file(MAKE_DIRECTORY ${build_dir}/test-deps)
+    add_custom_command(
+        OUTPUT  test-deps/.success
+        COMMAND ${PERL_EXECUTABLE} ${tools_dir}/check-depends.pl ${oa_opts} --expected="${td_exp}" ${build_dir}/${lib_file}
+        COMMAND ${CMAKE_COMMAND} -E touch test-deps/.success
+        DEPENDS ${build_dir}/${lib_file} ${tools_dir}/check-depends.pl
+    )
+else()
+    if(${tests} AND ${test_deps})
+        set(test_deps_message 'test-deps is available for dynamic libraries on Linux, Mac, Intel(R) MIC Architecture, Windows and static libraries on Windows.  Will not perform it.')
+    else()
+        set(test_deps_message "test-deps is turned off.  Will not perform it.")
+    endif()
+    add_custom_command(
+        OUTPUT  test-deps/.success
+        COMMAND ${CMAKE_COMMAND} -E echo ${test_deps_message}
+    )
+endif()
+# END OF TESTS
+######################################################
diff --git a/runtime/cmake/PerlFlags.cmake b/runtime/cmake/PerlFlags.cmake
new file mode 100644
index 0000000..c34d29d
--- /dev/null
+++ b/runtime/cmake/PerlFlags.cmake
@@ -0,0 +1,90 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#//                     The LLVM Compiler Infrastructure
+#//
+#// This file is dual licensed under the MIT and the University of Illinois Open
+#// Source Licenses. See LICENSE.txt for details.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+# void append_ev_flags(string new_flag);
+# - appends new_flag to ev_flags list
+macro(append_ev_flags new_flag)
+    list(APPEND local_ev_flags "${new_flag}")
+endmacro()
+
+# void append_gd_flags(string new_flag);
+# - appends new_flag to gd_flags list
+macro(append_gd_flags new_flag)
+    list(APPEND local_gd_flags "${new_flag}")
+endmacro()
+
+include(HelperFunctions) # for set_legal_type(), set_legal_arch()
+
+# Perl expand-vars.pl flags
+function(set_ev_flags input_ev_flags)
+    set(local_ev_flags)
+    set_legal_type("${lib_type}" legal_type)
+    set_legal_arch("${arch}" legal_arch)
+    # need -D Revision="\$Revision" to show up
+    append_ev_flags("-D Revision=\"\\\\$$Revision\"") 
+    append_ev_flags("-D Date=\"\\\\$$Date\"")
+    append_ev_flags("-D KMP_TYPE=\"${legal_type}\"")
+    append_ev_flags("-D KMP_ARCH=\"${legal_arch}\"")
+    append_ev_flags("-D KMP_VERSION_MAJOR=${version}")
+    append_ev_flags("-D KMP_VERSION_MINOR=0")
+    append_ev_flags("-D KMP_VERSION_BUILD=${build_number}")
+    append_ev_flags("-D KMP_BUILD_DATE=\"${date}\"")
+    append_ev_flags("-D KMP_TARGET_COMPILER=12")
+    if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
+        append_ev_flags("-D KMP_DIAG=1")
+        append_ev_flags("-D KMP_DEBUG_INFO=1")
+    else()
+        append_ev_flags("-D KMP_DIAG=0")
+        append_ev_flags("-D KMP_DEBUG_INFO=0")
+    endif()
+    if(${omp_version} EQUAL 40)
+        append_ev_flags("-D OMP_VERSION=201307")
+    elseif(${omp_version} EQUAL 30)
+        append_ev_flags("-D OMP_VERSION=201107")
+    else()
+        append_ev_flags("-D OMP_VERSION=200505")
+    endif()
+    set(${input_ev_flags} "${local_ev_flags}" PARENT_SCOPE)
+endfunction()
+
+function(set_gd_flags input_gd_flags)
+    set(local_gd_flags)
+    if(${IA32})
+        append_gd_flags("-D arch_32")
+    elseif(${INTEL64})
+        append_gd_flags("-D arch_32e")
+    else()
+        append_gd_flags("-D arch_${arch}")
+    endif()
+    if(${NORMAL_LIBRARY})
+        append_gd_flags("-D norm")
+    elseif(${PROFILE_LIBRARY})
+        append_gd_flags("-D prof")
+    elseif(${STUBS_LIBRARY})
+        append_gd_flags("-D stub")
+    endif()
+    if(${omp_version} GREATER 40 OR ${omp_version} EQUAL 40)
+        append_gd_flags("-D OMP_40")
+    endif()
+    if(${omp_version} GREATER 30 OR ${omp_version} EQUAL 30)
+        append_gd_flags("-D OMP_30")
+    endif()
+    if(NOT "${version}" STREQUAL "4")
+        append_gd_flags("-D msvc_compat")
+    endif()
+    if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
+        append_gd_flags("-D KMP_DEBUG")
+    endif()
+    if(${COMPILER_SUPPORTS_QUAD_PRECISION})
+        append_gd_flags("-D HAVE_QUAD")
+    endif()
+    set(${input_gd_flags} "${local_gd_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/runtime/cmake/SourceFiles.cmake b/runtime/cmake/SourceFiles.cmake
new file mode 100644
index 0000000..a884fea
--- /dev/null
+++ b/runtime/cmake/SourceFiles.cmake
@@ -0,0 +1,110 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#//                     The LLVM Compiler Infrastructure
+#//
+#// This file is dual licensed under the MIT and the University of Illinois Open
+#// Source Licenses. See LICENSE.txt for details.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+macro(append_c_source_file new_c_file)
+    list(APPEND local_c_source_files "${new_c_file}")
+endmacro()
+
+macro(append_cpp_source_file new_cpp_file)
+    list(APPEND local_cpp_source_files "${new_cpp_file}")
+endmacro()
+
+macro(append_asm_source_file new_asm_file)
+    list(APPEND local_asm_source_files "${new_asm_file}")
+endmacro()
+
+macro(append_imp_c_source_file new_import_c_file)
+    list(APPEND local_imp_c_files "${new_import_c_file}")
+endmacro()
+
+# files are relative to the src directory
+
+function(set_c_files input_c_source_files) 
+    set(local_c_source_files "")
+    append_c_source_file("kmp_ftn_cdecl.c")
+    append_c_source_file("kmp_ftn_extra.c")
+    append_c_source_file("kmp_version.c")
+    if(${STUBS_LIBRARY})
+        append_c_source_file("kmp_stub.c")
+    else()
+        append_c_source_file("kmp_alloc.c")
+        append_c_source_file("kmp_atomic.c")
+        append_c_source_file("kmp_csupport.c")
+        append_c_source_file("kmp_debug.c")
+        append_c_source_file("kmp_itt.c")
+        append_c_source_file("kmp_environment.c")
+        append_c_source_file("kmp_error.c")
+        append_c_source_file("kmp_global.c")
+        append_c_source_file("kmp_i18n.c")
+        append_c_source_file("kmp_io.c")
+        append_c_source_file("kmp_runtime.c")
+        append_c_source_file("kmp_settings.c")
+        append_c_source_file("kmp_str.c")
+        append_c_source_file("kmp_tasking.c")
+        append_c_source_file("kmp_taskq.c")
+        append_c_source_file("kmp_threadprivate.c")
+        append_c_source_file("kmp_utility.c")
+        if(${USE_ITT_NOTIFY})
+            append_c_source_file("thirdparty/ittnotify/ittnotify_static.c")
+        endif()
+        if(${WINDOWS})
+            append_c_source_file("z_Windows_NT_util.c")
+            append_c_source_file("z_Windows_NT-586_util.c")
+        else()
+            append_c_source_file("z_Linux_util.c")
+            append_c_source_file("kmp_gsupport.c")
+        endif()
+    endif()
+    set(${input_c_source_files} "${local_c_source_files}" PARENT_SCOPE)
+endfunction()
+
+function(set_cpp_files input_cpp_source_files) 
+    set(local_cpp_source_files "")
+    if(NOT ${STUBS_LIBRARY})
+        #append_cpp_source_file("kmp_barrier.cpp")
+        append_cpp_source_file("kmp_affinity.cpp")
+        append_cpp_source_file("kmp_dispatch.cpp")
+        append_cpp_source_file("kmp_lock.cpp")
+        append_cpp_source_file("kmp_sched.cpp")
+        if("${omp_version}" STREQUAL "40")
+            append_cpp_source_file("kmp_taskdeps.cpp")
+            append_cpp_source_file("kmp_cancel.cpp")
+        endif()
+        #if(${STATS_GATHERING})
+        #   append_cpp_source_file("kmp_stats.cpp")
+        #    append_cpp_source_file("kmp_stats_timing.cpp")
+        #endif()
+    endif()
+
+    set(${input_cpp_source_files} "${local_cpp_source_files}" PARENT_SCOPE)
+endfunction()
+
+
+function(set_asm_files input_asm_source_files) 
+    set(local_asm_source_files "")
+    if(NOT ${STUBS_LIBRARY})
+        if(${WINDOWS})
+            append_asm_source_file("z_Windows_NT-586_asm.asm")
+        else()
+            append_asm_source_file("z_Linux_asm.s")
+        endif()
+    endif()
+    set(${input_asm_source_files} "${local_asm_source_files}" PARENT_SCOPE)
+endfunction()
+
+
+function(set_imp_c_files input_imp_c_files)
+    set(local_imp_c_files "")
+    if(${WINDOWS})
+        append_imp_c_source_file("kmp_import.c")
+    endif()
+    set(${input_imp_c_files} "${local_imp_c_files}" PARENT_SCOPE)
+endfunction()
diff --git a/runtime/src/CMakeLists.txt b/runtime/src/CMakeLists.txt
index dd29966..bfc8540 100644
--- a/runtime/src/CMakeLists.txt
+++ b/runtime/src/CMakeLists.txt
@@ -22,11 +22,17 @@
   message(FATAL_ERROR "Unsupported OS")
 endif()
 
-if("${ARCH}" STREQUAL "")
+if(arch)	
+	set(ARCH ${arch}) #acquire from command line
+else() #assume default
   set(ARCH "32e")
 endif()
 
-set(ARCH_STR "Intel(R) 64")
+if("${arch}" STREQUAL "32e")
+  set(ARCH_STR "Intel(R) 64")
+elseif("${arch}" STREQUAL "ppc64")
+  set(ARCH_STR "PPC64")
+endif()
 
 set(FEATURE_FLAGS "-D USE_ITT_BUILD")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D NDEBUG")
@@ -36,13 +42,22 @@
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_USE_ASSERT")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D BUILD_I8")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D BUILD_TV")
+
 if(APPLE)
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -current_version 5.0")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -compatibility_version 5.0")
 endif()
+
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_LIBRARY_FILE=\\\"libiomp5.${OMP_SHLIBEXT}\\\"")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_VERSION_MAJOR=${VERSION}")
-set(FEATURE_FLAGS "${FEATURE_FLAGS} -D CACHE_LINE=64")
+
+# customize cache line size for ppc64 to 128 bytes: 64 in all other cases
+if("${arch}" STREQUAL "ppc64")
+	set(FEATURE_FLAGS "${FEATURE_FLAGS} -D CACHE_LINE=128")
+else()
+	set(FEATURE_FLAGS "${FEATURE_FLAGS} -D CACHE_LINE=64")	
+endif()
+
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_ADJUST_BLOCKTIME=1")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D BUILD_PARALLEL_ORDERED")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_ASM_INTRINS")
@@ -50,8 +65,13 @@
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D USE_CBLKDATA")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D GUIDEDLL_EXPORTS")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_GOMP_COMPAT")
-set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_USE_ADAPTIVE_LOCKS=1")
-set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_DEBUG_ADAPTIVE_LOCKS=0")
+
+#adaptive locks use x86 assembly - disable for ppc64
+if("${arch}" STREQUAL "32e" OR "${arch}" STREQUAL "32" OR "${arch}" STREQUAL "arm")
+	set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_USE_ADAPTIVE_LOCKS=1")
+	set(FEATURE_FLAGS "${FEATURE_FLAGS} -D KMP_DEBUG_ADAPTIVE_LOCKS=0")
+endif()
+
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D OMP_50_ENABLED=0")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D OMP_41_ENABLED=0")
 set(FEATURE_FLAGS "${FEATURE_FLAGS} -D OMP_40_ENABLED=1")
@@ -122,16 +142,38 @@
   OUTPUT omp.h
     COMMAND perl ${CMAKE_CURRENT_SOURCE_DIR}/../tools/expand-vars.pl --strict -D Revision=\"\\$$Revision\" -D Date=\"\\$$Date\" -D KMP_TYPE=\"Performance\" -D KMP_ARCH=\"\\\"${ARCH_STR}\\\"\" -D KMP_VERSION_MAJOR=${VERSION} -D KMP_VERSION_MINOR=0 -D KMP_VERSION_BUILD=00000000 -D KMP_BUILD_DATE=\"${BUILD_TIME} UTC\" -D KMP_TARGET_COMPILER=12 -D KMP_DIAG=0 -D KMP_DEBUG_INFO=0 -D OMP_VERSION=${OMP_VERSION} ${CMAKE_CURRENT_SOURCE_DIR}/include/${OMP_VERSION_NUM}/omp.h.var omp.h
 )
-add_custom_command(
-  OUTPUT z_Linux_asm.o
-    COMMAND ${CMAKE_CXX_COMPILER} -c -o z_Linux_asm.o -D KMP_ASM_INTRINS -D KMP_GOMP_COMPAT -D KMP_ARCH_X86_64 -x assembler-with-cpp ${CMAKE_CURRENT_SOURCE_DIR}/${ASM_SOURCES}
-)
+
+if("${ARCH}" STREQUAL "ppc64")
+	add_custom_command(
+		OUTPUT z_Linux_asm.o
+    		       COMMAND ${CMAKE_CXX_COMPILER} -c -o z_Linux_asm.o -D KMP_ASM_INTRINS -D KMP_GOMP_COMPAT -D KMP_ARCH_PPC64 -x assembler-with-cpp ${CMAKE_CURRENT_SOURCE_DIR}/${ASM_SOURCES}
+		       )
+else()
+	add_custom_command(
+		OUTPUT z_Linux_asm.o
+    		       COMMAND ${CMAKE_CXX_COMPILER} -c -o z_Linux_asm.o -D KMP_ASM_INTRINS -D KMP_GOMP_COMPAT -D KMP_ARCH_X86_64 -x assembler-with-cpp ${CMAKE_CURRENT_SOURCE_DIR}/${ASM_SOURCES}
+		       )
+endif()
+
 
 add_custom_target(gen_kmp_i18n DEPENDS kmp_i18n_id.inc kmp_i18n_default.inc omp.h z_Linux_asm.o)
 
 if(NOT APPLE)
-  set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/exports_so.txt")
+	if(${ARCH} STREQUAL "ppc64" AND ${OS_GEN} STREQUAL "lin")
+  		set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/exports_so.txt -ldl")
+ 	else()
+   		set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/exports_so.txt")
+	endif()
 endif()
 
 add_library(iomp5 SHARED ${SOURCES} z_Linux_asm.o)
+
+# This is a workaround to a known ppc64 issue about libpthread. For more
+# information see
+# http://ryanarn.blogspot.com/2011/07/curious-case-of-pthreadatfork-on.html
+if("${ARCH}" STREQUAL "ppc64")
+	      find_library(PTHREAD NAMES pthread)
+	      target_link_libraries(iomp5 ${PTHREAD})
+endif()
+
 add_dependencies(iomp5 gen_kmp_i18n)
diff --git a/runtime/src/dllexports b/runtime/src/dllexports
index 779f1d4..2c58f4c 100644
--- a/runtime/src/dllexports
+++ b/runtime/src/dllexports
@@ -471,7 +471,9 @@
 
     # ATOMIC entries
 
+    %ifdef HAVE_QUAD
     __kmpc_atomic_cmplx16_div              2000
+    %endif
 
     __kmpc_atomic_fixed1_add               2001
     __kmpc_atomic_fixed1_andb              2002
@@ -577,6 +579,7 @@
     __kmpc_atomic_cmplx10_sub              2094
     __kmpc_atomic_cmplx10_mul              2095
     __kmpc_atomic_cmplx10_div              2096
+    %ifdef HAVE_QUAD
     __kmpc_atomic_cmplx16_add              2097
     __kmpc_atomic_cmplx16_sub              2098
     __kmpc_atomic_cmplx16_mul              2099
@@ -627,6 +630,7 @@
     __kmpc_atomic_float10_sub_fp           2136
     __kmpc_atomic_float10_mul_fp           2137
     __kmpc_atomic_float10_div_fp           2138
+    %endif
 
     __kmpc_atomic_fixed1_mul_float8        2169
     __kmpc_atomic_fixed1_div_float8        2170
@@ -661,6 +665,7 @@
 
     %ifdef arch_32
 
+        %ifdef HAVE_QUAD
         __kmpc_atomic_float16_add_a16      2255
         __kmpc_atomic_float16_sub_a16      2256
         __kmpc_atomic_float16_mul_a16      2257
@@ -672,6 +677,7 @@
         __kmpc_atomic_cmplx16_sub_a16      2262
         __kmpc_atomic_cmplx16_mul_a16      2263
         __kmpc_atomic_cmplx16_div_a16      2264
+        %endif
 
     %endif
 
@@ -686,14 +692,18 @@
         __kmpc_atomic_float4_rd                2269
         __kmpc_atomic_float8_rd                2270
         __kmpc_atomic_float10_rd               2271
+        %ifdef HAVE_QUAD
         __kmpc_atomic_float16_rd               2272
+        %endif
         __kmpc_atomic_cmplx4_rd                2273
         __kmpc_atomic_cmplx8_rd                2274
         __kmpc_atomic_cmplx10_rd               2275
+        %ifdef HAVE_QUAD
         __kmpc_atomic_cmplx16_rd               2276
-        %ifdef arch_32
-            __kmpc_atomic_float16_a16_rd       2277
-            __kmpc_atomic_cmplx16_a16_rd       2278
+            %ifdef arch_32
+                __kmpc_atomic_float16_a16_rd       2277
+                __kmpc_atomic_cmplx16_a16_rd       2278
+            %endif
         %endif
         __kmpc_atomic_fixed1_wr                2279
         __kmpc_atomic_fixed2_wr                2280
@@ -702,15 +712,19 @@
         __kmpc_atomic_float4_wr                2283
         __kmpc_atomic_float8_wr                2284
         __kmpc_atomic_float10_wr               2285
+        %ifdef HAVE_QUAD
         __kmpc_atomic_float16_wr               2286
+        %endif
         __kmpc_atomic_cmplx4_wr                2287
         __kmpc_atomic_cmplx8_wr                2288
         __kmpc_atomic_cmplx10_wr               2289
+        %ifdef HAVE_QUAD
         __kmpc_atomic_cmplx16_wr               2290
         %ifdef arch_32
             __kmpc_atomic_float16_a16_wr       2291
             __kmpc_atomic_cmplx16_a16_wr       2292
         %endif
+        %endif
         __kmpc_atomic_fixed1_add_cpt           2293
         __kmpc_atomic_fixed1_andb_cpt          2294
         __kmpc_atomic_fixed1_div_cpt           2295
@@ -783,8 +797,10 @@
         __kmpc_atomic_float4_min_cpt           2362
         __kmpc_atomic_float8_max_cpt           2363
         __kmpc_atomic_float8_min_cpt           2364
+        %ifdef HAVE_QUAD
         __kmpc_atomic_float16_max_cpt          2365
         __kmpc_atomic_float16_min_cpt          2366
+        %endif
         __kmpc_atomic_fixed1_neqv_cpt          2367
         __kmpc_atomic_fixed2_neqv_cpt          2368
         __kmpc_atomic_fixed4_neqv_cpt          2369
@@ -797,10 +813,12 @@
         __kmpc_atomic_float10_sub_cpt          2376
         __kmpc_atomic_float10_mul_cpt          2377
         __kmpc_atomic_float10_div_cpt          2378
+        %ifdef HAVE_QUAD
         __kmpc_atomic_float16_add_cpt          2379
         __kmpc_atomic_float16_sub_cpt          2380
         __kmpc_atomic_float16_mul_cpt          2381
         __kmpc_atomic_float16_div_cpt          2382
+        %endif
         __kmpc_atomic_cmplx4_add_cpt           2383
         __kmpc_atomic_cmplx4_sub_cpt           2384
         __kmpc_atomic_cmplx4_mul_cpt           2385
@@ -813,13 +831,16 @@
         __kmpc_atomic_cmplx10_sub_cpt          2392
         __kmpc_atomic_cmplx10_mul_cpt          2393
         __kmpc_atomic_cmplx10_div_cpt          2394
+        %ifdef HAVE_QUAD
         __kmpc_atomic_cmplx16_add_cpt          2395
         __kmpc_atomic_cmplx16_sub_cpt          2396
         __kmpc_atomic_cmplx16_mul_cpt          2397
         __kmpc_atomic_cmplx16_div_cpt          2398
+        %endif
        #__kmpc_atomic_cmplx4_add_cpt_tmp            2409
 
         %ifdef arch_32
+        %ifdef HAVE_QUAD
             __kmpc_atomic_float16_add_a16_cpt  2399
             __kmpc_atomic_float16_sub_a16_cpt  2400
             __kmpc_atomic_float16_mul_a16_cpt  2401
@@ -831,6 +852,7 @@
             __kmpc_atomic_cmplx16_mul_a16_cpt  2407
             __kmpc_atomic_cmplx16_div_a16_cpt  2408
         %endif
+        %endif
 
         __kmpc_atomic_start                    2410
         __kmpc_atomic_end                      2411
@@ -846,16 +868,20 @@
             __kmpc_atomic_float4_swp           2416
             __kmpc_atomic_float8_swp           2417
             __kmpc_atomic_float10_swp          2418
+            %ifdef HAVE_QUAD
               __kmpc_atomic_float16_swp        2419
+            %endif
             __kmpc_atomic_cmplx4_swp           2420
             __kmpc_atomic_cmplx8_swp           2421
             __kmpc_atomic_cmplx10_swp          2422
+            %ifdef HAVE_QUAD
             __kmpc_atomic_cmplx16_swp          2423
 
             %ifdef arch_32
                 __kmpc_atomic_float16_a16_swp  2424
                 __kmpc_atomic_cmplx16_a16_swp  2425
             %endif
+            %endif
 
             __kmpc_atomic_fixed1_sub_cpt_rev   2426
             __kmpc_atomic_fixed1_div_cpt_rev   2427
@@ -887,14 +913,17 @@
             __kmpc_atomic_float8_div_cpt_rev   2453
             __kmpc_atomic_float10_sub_cpt_rev  2454
             __kmpc_atomic_float10_div_cpt_rev  2455
+            %ifdef HAVE_QUAD
             __kmpc_atomic_float16_sub_cpt_rev  2456
             __kmpc_atomic_float16_div_cpt_rev  2457
+            %endif
             __kmpc_atomic_cmplx4_sub_cpt_rev   2458
             __kmpc_atomic_cmplx4_div_cpt_rev   2459
             __kmpc_atomic_cmplx8_sub_cpt_rev   2460
             __kmpc_atomic_cmplx8_div_cpt_rev   2461
             __kmpc_atomic_cmplx10_sub_cpt_rev  2462
             __kmpc_atomic_cmplx10_div_cpt_rev  2463
+            %ifdef HAVE_QUAD
             __kmpc_atomic_cmplx16_sub_cpt_rev  2464
             __kmpc_atomic_cmplx16_div_cpt_rev  2465
 
@@ -904,6 +933,7 @@
                 __kmpc_atomic_cmplx16_sub_a16_cpt_rev  2468
                 __kmpc_atomic_cmplx16_div_a16_cpt_rev  2469
             %endif
+            %endif
 
         %endif   # OMP_40
 
diff --git a/runtime/src/kmp.h b/runtime/src/kmp.h
index a8c600b..f5dd10f 100644
--- a/runtime/src/kmp.h
+++ b/runtime/src/kmp.h
@@ -459,9 +459,9 @@
 /*
  * Only Linux* OS and Windows* OS support thread affinity.
  */
-#if KMP_OS_LINUX || KMP_OS_WINDOWS
+#if (KMP_OS_LINUX || KMP_OS_WINDOWS) && !KMP_OS_CNK && !KMP_ARCH_PPC64
 # define KMP_AFFINITY_SUPPORTED 1
-#elif KMP_OS_DARWIN || KMP_OS_FREEBSD
+#elif KMP_OS_DARWIN || KMP_OS_FREEBSD || KMP_OS_CNK || KMP_ARCH_PPC64
 // affinity not supported
 # define KMP_AFFINITY_SUPPORTED 0
 #else
@@ -476,7 +476,7 @@
 
 # if KMP_OS_LINUX
 //
-// On Linux* OS, the mask isactually a vector of length __kmp_affin_mask_size
+// On Linux* OS, the mask is actually a vector of length __kmp_affin_mask_size
 // (in bytes).  It should be allocated on a word boundary.
 //
 // WARNING!!!  We have made the base type of the affinity mask unsigned char,
@@ -946,6 +946,9 @@
 #if KMP_OS_WINDOWS
 #  define KMP_INIT_WAIT    64U          /* initial number of spin-tests   */
 #  define KMP_NEXT_WAIT    32U          /* susequent number of spin-tests */
+#elif KMP_OS_CNK
+#  define KMP_INIT_WAIT    16U          /* initial number of spin-tests   */
+#  define KMP_NEXT_WAIT     8U          /* susequent number of spin-tests */
 #elif KMP_OS_LINUX
 #  define KMP_INIT_WAIT  1024U          /* initial number of spin-tests   */
 #  define KMP_NEXT_WAIT   512U          /* susequent number of spin-tests */
@@ -971,6 +974,11 @@
   extern void __kmp_x86_pause( void );
 # endif
 # define KMP_CPU_PAUSE()        __kmp_x86_pause()
+#elif KMP_ARCH_PPC64
+# define KMP_PPC64_PRI_LOW() __asm__ volatile ("or 1, 1, 1")
+# define KMP_PPC64_PRI_MED() __asm__ volatile ("or 2, 2, 2")
+# define KMP_PPC64_PRI_LOC_MB() __asm__ volatile ("" : : : "memory")
+# define KMP_CPU_PAUSE() do { KMP_PPC64_PRI_LOW(); KMP_PPC64_PRI_MED(); KMP_PPC64_PRI_LOC_MB(); } while (0)
 #else
 # define KMP_CPU_PAUSE()        /* nothing to do */
 #endif
diff --git a/runtime/src/kmp_csupport.c b/runtime/src/kmp_csupport.c
index 18b6c35..780bd41 100644
--- a/runtime/src/kmp_csupport.c
+++ b/runtime/src/kmp_csupport.c
@@ -828,7 +828,7 @@
                 if ( ! __kmp_cpuinfo.sse2 ) {
                     // CPU cannot execute SSE2 instructions.
                 } else {
-                    #if KMP_COMPILER_ICC
+                    #if KMP_COMPILER_ICC || KMP_COMPILER_MSVC
                     _mm_mfence();
                     #else
                     __sync_synchronize();
@@ -837,6 +837,19 @@
             #endif // KMP_MIC
         #elif KMP_ARCH_ARM
             // Nothing yet
+	     #elif KMP_ARCH_PPC64
+            // Nothing needed here (we have a real MB above).
+            #if KMP_OS_CNK
+	     	 // The flushing thread needs to yield here; this prevents a
+		    // busy-waiting thread from saturating the pipeline. flush is
+		       // often used in loops like this:
+                // while (!flag) {
+                //   #pragma omp flush(flag)
+                // }
+		    // and adding the yield here is good for at least a 10x speedup
+		       // when running >2 threads per core (on the NAS LU benchmark).
+                __kmp_yield(TRUE);
+            #endif
         #else
             #error Unknown or unsupported architecture
         #endif
diff --git a/runtime/src/kmp_ftn_entry.h b/runtime/src/kmp_ftn_entry.h
index 8bb75d4..280d76f 100644
--- a/runtime/src/kmp_ftn_entry.h
+++ b/runtime/src/kmp_ftn_entry.h
@@ -263,7 +263,7 @@
 
     #if KMP_OS_WINDOWS && KMP_ARCH_X86_64
         if ( __kmp_num_proc_groups <= 1 ) {
-            return KMP_CPU_SETSIZE;
+            return (int)KMP_CPU_SETSIZE;
         }
     #endif /* KMP_OS_WINDOWS && KMP_ARCH_X86_64 */
         return __kmp_xproc;
@@ -412,7 +412,7 @@
             gtid = __kmp_entry_gtid();
         #elif KMP_OS_WINDOWS
             if (!__kmp_init_parallel ||
-                (gtid = ((kmp_intptr_t)TlsGetValue( __kmp_gtid_threadprivate_key ))) == 0) {
+                (gtid = (int)((kmp_intptr_t)TlsGetValue( __kmp_gtid_threadprivate_key ))) == 0) {
                 // Either library isn't initialized or thread is not registered
                 // 0 is the correct TID in this case
                 return 0;
@@ -463,7 +463,6 @@
     #ifdef KMP_STUB
         return 1;
     #else
-        int gtid;
         if ( ! TCR_4(__kmp_init_middle) ) {
             __kmp_middle_initialize();
         }
@@ -1013,7 +1012,7 @@
 {
     #ifndef KMP_STUB
         #ifdef PASS_ARGS_BY_VALUE
-            int len = strlen( str );
+            int len = (int)strlen( str );
         #endif
         __kmp_aux_set_defaults( str, len );
     #endif
diff --git a/runtime/src/kmp_ftn_os.h b/runtime/src/kmp_ftn_os.h
index f241751..d78d846 100644
--- a/runtime/src/kmp_ftn_os.h
+++ b/runtime/src/kmp_ftn_os.h
@@ -478,7 +478,7 @@
 //#define KMP_API_NAME_GOMP_TARGET_UPDATE                GOMP_target_update
 #define KMP_API_NAME_GOMP_TEAMS                          GOMP_teams
 
-#if KMP_OS_LINUX
+#if KMP_OS_LINUX && !KMP_OS_CNK && !KMP_ARCH_PPC64
     #define xstr(x) str(x) 
     #define str(x) #x
 
diff --git a/runtime/src/kmp_global.c b/runtime/src/kmp_global.c
index aa1f8e3..d3c3195 100644
--- a/runtime/src/kmp_global.c
+++ b/runtime/src/kmp_global.c
@@ -321,7 +321,11 @@
 kmp_uint32 __kmp_yield_init = KMP_INIT_WAIT;
 kmp_uint32 __kmp_yield_next = KMP_NEXT_WAIT;
 kmp_uint32 __kmp_yielding_on = 1;
+#if KMP_OS_CNK
+kmp_uint32 __kmp_yield_cycle = 0;
+#else
 kmp_uint32 __kmp_yield_cycle = 1;     /* Yield-cycle is on by default */
+#endif
 kmp_int32  __kmp_yield_on_count = 10; /* By default, yielding is on for 10 monitor periods. */
 kmp_int32  __kmp_yield_off_count = 1; /* By default, yielding is off for 1 monitor periods. */
 /* ----------------------------------------------------- */
diff --git a/runtime/src/kmp_gsupport.c b/runtime/src/kmp_gsupport.c
index 9d8e553..aa52024 100644
--- a/runtime/src/kmp_gsupport.c
+++ b/runtime/src/kmp_gsupport.c
@@ -15,7 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 
-#if defined(__x86_64)
+#if defined(__x86_64) || defined (__powerpc64__)
 # define KMP_I8
 #endif
 #include "kmp.h"
diff --git a/runtime/src/kmp_lock.h b/runtime/src/kmp_lock.h
index 8009d18..c5ce838 100644
--- a/runtime/src/kmp_lock.h
+++ b/runtime/src/kmp_lock.h
@@ -518,7 +518,7 @@
 // Internal RTL locks are also implemented as ticket locks, for now.
 //
 // FIXME - We should go through and figure out which lock kind works best for
-// each internal lock, and use the type deeclaration and function calls for
+// each internal lock, and use the type declaration and function calls for
 // that explicit lock kind (and get rid of this section).
 //
 
diff --git a/runtime/src/kmp_os.h b/runtime/src/kmp_os.h
index bb5e72f..489f8f7 100644
--- a/runtime/src/kmp_os.h
+++ b/runtime/src/kmp_os.h
@@ -46,6 +46,7 @@
 #define KMP_COMPILER_ICC 0
 #define KMP_COMPILER_GCC 0
 #define KMP_COMPILER_CLANG 0
+#define KMP_COMPILER_MSVC 0
 
 #if defined( __INTEL_COMPILER )
 # undef KMP_COMPILER_ICC
@@ -56,6 +57,9 @@
 #elif defined( __GNUC__ )
 # undef KMP_COMPILER_GCC
 # define KMP_COMPILER_GCC 1
+#elif defined( _MSC_VER )
+# undef KMP_COMPILER_MSVC
+# define KMP_COMPILER_MSVC 1
 #else
 # error Unknown compiler
 #endif
@@ -66,10 +70,12 @@
 #define KMP_OS_FREEBSD  0
 #define KMP_OS_DARWIN   0
 #define KMP_OS_WINDOWS    0
+#define KMP_OS_CNK      0
 #define KMP_OS_UNIX     0  /* disjunction of KMP_OS_LINUX, KMP_OS_DARWIN etc. */
 
 #define KMP_ARCH_X86        0
 #define KMP_ARCH_X86_64	    0
+#define KMP_ARCH_PPC64      0
 
 #ifdef _WIN32
 # undef KMP_OS_WINDOWS
@@ -81,9 +87,14 @@
 # define KMP_OS_DARWIN 1
 #endif
 
+// in some ppc64 linux installations, only the second condition is met
 #if ( defined __linux )
 # undef KMP_OS_LINUX
 # define KMP_OS_LINUX 1
+#elif ( defined __linux__)
+# undef KMP_OS_LINUX
+# define KMP_OS_LINUX 1
+#else
 #endif
 
 #if ( defined __FreeBSD__ )
@@ -91,6 +102,11 @@
 # define KMP_OS_FREEBSD 1
 #endif
 
+#if ( defined __bgq__ )
+# undef KMP_OS_CNK
+# define KMP_OS_CNK 1
+#endif
+
 #if (1 != KMP_OS_LINUX + KMP_OS_FREEBSD + KMP_OS_DARWIN + KMP_OS_WINDOWS)
 # error Unknown OS
 #endif
@@ -117,6 +133,9 @@
 # elif defined __i386
 #  undef KMP_ARCH_X86
 #  define KMP_ARCH_X86 1
+# elif defined __powerpc64__
+#  undef KMP_ARCH_PPC64
+#  define KMP_ARCH_PPC64 1
 # endif
 #endif
 
@@ -156,7 +175,7 @@
 # define KMP_ARCH_ARM 1
 #endif
 
-#if (1 != KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM)
+#if (1 != KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64)
 # error Unknown or unsupported architecture
 #endif
 
@@ -175,6 +194,8 @@
    typedef __float128 _Quad;
 #  undef  KMP_HAVE_QUAD
 #  define KMP_HAVE_QUAD 1
+# elif KMP_COMPILER_MSVC
+   typedef long double _Quad;
 # endif
 #else
 # if __LDBL_MAX_EXP__ >= 16384 && KMP_COMPILER_GCC
@@ -232,7 +253,7 @@
 
 #if KMP_ARCH_X86 || KMP_ARCH_ARM
 # define KMP_SIZE_T_SPEC KMP_UINT32_SPEC
-#elif KMP_ARCH_X86_64
+#elif KMP_ARCH_X86_64 || KMP_ARCH_PPC64
 # define KMP_SIZE_T_SPEC KMP_UINT64_SPEC
 #else
 # error "Can't determine size_t printf format specifier."
@@ -657,6 +678,10 @@
 # endif
 #endif /* KMP_OS_WINDOWS */
 
+#if KMP_ARCH_PPC64
+# define KMP_MB()       __sync_synchronize()
+#endif
+
 #ifndef KMP_MB
 # define KMP_MB()       /* nothing to do */
 #endif
@@ -763,7 +788,7 @@
 #endif /* KMP_I8 */
 
 /* Workaround for Intel(R) 64 code gen bug when taking address of static array (Intel(R) 64 Tracker #138) */
-#if KMP_ARCH_X86_64 && KMP_OS_LINUX
+#if (KMP_ARCH_X86_64 || KMP_ARCH_PPC64) && KMP_OS_LINUX
 # define STATIC_EFI2_WORKAROUND
 #else
 # define STATIC_EFI2_WORKAROUND static
diff --git a/runtime/src/kmp_runtime.c b/runtime/src/kmp_runtime.c
index fea41d0..d243700 100644
--- a/runtime/src/kmp_runtime.c
+++ b/runtime/src/kmp_runtime.c
@@ -8450,7 +8450,7 @@
         int atomic_available = FAST_REDUCTION_ATOMIC_METHOD_GENERATED;
         int tree_available   = FAST_REDUCTION_TREE_METHOD_GENERATED;
 
-        #if KMP_ARCH_X86_64
+        #if KMP_ARCH_X86_64 || KMP_ARCH_PPC64
 
             #if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS || KMP_OS_DARWIN
                 #if KMP_MIC
diff --git a/runtime/src/kmp_settings.c b/runtime/src/kmp_settings.c
index 54745cb..b85678e 100644
--- a/runtime/src/kmp_settings.c
+++ b/runtime/src/kmp_settings.c
@@ -536,6 +536,7 @@
 
 static char * par_range_to_print = NULL;
 
+#ifdef KMP_DEBUG
 static void
 __kmp_stg_parse_par_range(
     char const * name,
@@ -614,7 +615,7 @@
         break;
     }
 } // __kmp_stg_parse_par_range
-
+#endif
 
 int
 __kmp_initial_threads_capacity( int req_nproc )
diff --git a/runtime/src/kmp_str.h b/runtime/src/kmp_str.h
index 634d1f1..7de3a2e 100644
--- a/runtime/src/kmp_str.h
+++ b/runtime/src/kmp_str.h
@@ -28,9 +28,8 @@
 #endif // __cplusplus
 
 #if KMP_OS_WINDOWS
-    #define strdup    _strdup
-    #define snprintf  _snprintf
-    #define vsnprintf _vsnprintf
+# define strdup    _strdup
+# define snprintf  _snprintf
 #endif
 
 /*  some macros to replace ctype.h functions  */
diff --git a/runtime/src/kmp_version.c b/runtime/src/kmp_version.c
index f64d052..b836c39 100644
--- a/runtime/src/kmp_version.c
+++ b/runtime/src/kmp_version.c
@@ -53,6 +53,8 @@
     #define KMP_COMPILER "Clang " stringer( __clang_major__ ) "." stringer( __clang_minor__ )
 #elif KMP_COMPILER_GCC
     #define KMP_COMPILER "GCC " stringer( __GNUC__ ) "." stringer( __GNUC_MINOR__ )
+#elif KMP_COMPILER_MSVC
+    #define KMP_COMPILER "MSVC " stringer( __MSC_FULL_VER )
 #endif
 #ifndef KMP_COMPILER
     #warning "Unknown compiler"
diff --git a/runtime/src/makefile.mk b/runtime/src/makefile.mk
index 9be8799..b4ed8e5 100644
--- a/runtime/src/makefile.mk
+++ b/runtime/src/makefile.mk
@@ -73,6 +73,8 @@
 TARGET_COMPILER := $(call check_variable,TARGET_COMPILER,12 11)
 # Library version: 4 -- legacy, 5 -- compat.
 VERSION      := $(call check_variable,VERSION,5 4)
+# quad precision floating point
+HAVE_QUAD     = 1
 
 VPATH += $(src_dir)
 VPATH += $(src_dir)i18n/
@@ -171,6 +173,7 @@
         ld-flags += -m32 -msse
         as-flags += -m32 -msse
     endif
+    HAVE_QUAD = 0
 endif
 
 ifeq "$(LINK_TYPE)" "dyna"
@@ -310,6 +313,9 @@
 ifeq "$(CPLUSPLUS)" "on"
     ifeq "$(os)" "win"
         c-flags   += -TP
+    else ifeq "$(arch)" "ppc64"
+    # c++0x on ppc64 linux removes definition of preproc. macros, needed in .hs
+      c-flags   += -x c++ -std=gnu++0x
     else
         ifneq "$(filter gcc clang,$(c))" ""
             c-flags   += -x c++ -std=c++0x
@@ -370,7 +376,7 @@
             ld-flags-extra += -lirc_pic
             endif
         endif
-        ifeq "$(filter 32 32e 64,$(arch))" ""
+        ifeq "$(filter 32 32e 64 ppc64,$(arch))" ""
             ld-flags-extra += $(shell pkg-config --libs libffi)
         endif
     else
@@ -466,7 +472,14 @@
 endif
 cpp-flags += -D KMP_LIBRARY_FILE=\"$(lib_file)\"
 cpp-flags += -D KMP_VERSION_MAJOR=$(VERSION)
-cpp-flags += -D CACHE_LINE=64
+
+# customize ppc64 cache line size to 128, 64 otherwise
+ifeq "$(arch)" "ppc64"
+	cpp-flags += -D CACHE_LINE=128
+else 
+	cpp-flags += -D CACHE_LINE=64
+endif
+
 cpp-flags += -D KMP_ADJUST_BLOCKTIME=1
 cpp-flags += -D BUILD_PARALLEL_ORDERED
 cpp-flags += -D KMP_ASM_INTRINS
@@ -581,9 +594,12 @@
     ifeq "$(arch)" "arm"
         z_Linux_asm$(obj) : \
 		    cpp-flags += -D KMP_ARCH_ARM
-    else
+    else ifeq "$(arch)" "ppc64" 
         z_Linux_asm$(obj) : \
-            cpp-flags += -D KMP_ARCH_X86$(if $(filter 32e,$(arch)),_64)
+			cpp-flags += -D KMP_ARCH_PPC64		    
+    else
+    	z_Linux_asm$(obj) : \
+       		cpp-flags += -D KMP_ARCH_X86$(if $(filter 32e,$(arch)),_64)	
     endif
 endif
 
@@ -596,6 +612,9 @@
 
 gd-flags += -D arch_$(arch)
 gd-flags += -D $(LIB_TYPE)
+ifeq "$(HAVE_QUAD)" "1"
+    gd-flags += -D HAVE_QUAD
+endif
 ifeq "$(OMP_VERSION)" "40"
     gd-flags += -D OMP_40 -D OMP_30
 else
@@ -729,7 +748,9 @@
         else # 5
             lib_c_items += kmp_gsupport
         endif
+#        ifneq "$(arch)" "ppc64"
         lib_asm_items += z_Linux_asm
+#	     endif
     endif
 endif
 
@@ -1391,9 +1412,13 @@
             td_exp += libc.so.6
             td_exp += ld-linux-armhf.so.3
         endif
+        ifeq "$(arch)" "ppc64"
+            td_exp += libc.so.6
+            td_exp += ld64.so.1
+        endif
         td_exp += libdl.so.2
         td_exp += libgcc_s.so.1
-        ifeq "$(filter 32 32e 64,$(arch))" ""
+        ifeq "$(filter 32 32e 64 ppc64,$(arch))" ""
             td_exp += libffi.so.6
             td_exp += libffi.so.5
         endif
diff --git a/runtime/src/thirdparty/ittnotify/ittnotify_config.h b/runtime/src/thirdparty/ittnotify/ittnotify_config.h
index 40c8614..9e7b36b 100644
--- a/runtime/src/thirdparty/ittnotify/ittnotify_config.h
+++ b/runtime/src/thirdparty/ittnotify/ittnotify_config.h
@@ -132,6 +132,11 @@
 #  define ITT_ARCH_ARM  4
 #endif /* ITT_ARCH_ARM */
 
+#ifndef ITT_ARCH_PPC64
+#  define ITT_ARCH_PPC64  5
+#endif /* ITT_ARCH_PPC64 */
+
+
 #ifndef ITT_ARCH
 #  if defined _M_IX86 || defined __i386__
 #    define ITT_ARCH ITT_ARCH_IA32
@@ -141,6 +146,8 @@
 #    define ITT_ARCH ITT_ARCH_IA64
 #  elif defined _M_ARM || __arm__
 #    define ITT_ARCH ITT_ARCH_ARM
+#  elif defined __powerpc64__
+#    define ITT_ARCH ITT_ARCH_PPC64
 #  endif
 #endif
 
@@ -274,7 +281,7 @@
                           : "memory");
     return result;
 }
-#elif ITT_ARCH==ITT_ARCH_ARM
+#elif ITT_ARCH==ITT_ARCH_ARM || ITT_ARCH==ITT_ARCH_PPC64
 #define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
 #endif /* ITT_ARCH==ITT_ARCH_IA64 */
 #ifndef ITT_SIMPLE_INIT
diff --git a/runtime/src/z_Linux_asm.s b/runtime/src/z_Linux_asm.s
index 1f1ba1b..64c8052 100644
--- a/runtime/src/z_Linux_asm.s
+++ b/runtime/src/z_Linux_asm.s
@@ -138,7 +138,7 @@
 #endif /* KMP_GOMP_COMPAT */
 
 
-#if KMP_ARCH_X86
+#if KMP_ARCH_X86 && !KMP_ARCH_PPC64
 
 // -----------------------------------------------------------------------
 // microtasking routines specifically written for IA-32 architecture
@@ -1585,6 +1585,16 @@
     .size __kmp_unnamed_critical_addr,4
 #endif /* KMP_ARCH_ARM */
 
+#if KMP_ARCH_PPC64
+    .data
+    .comm .gomp_critical_user_,32,8
+    .data
+    .align 8
+    .global __kmp_unnamed_critical_addr
+__kmp_unnamed_critical_addr:
+    .8byte .gomp_critical_user_
+    .size __kmp_unnamed_critical_addr,8
+#endif /* KMP_ARCH_PPC64 */
 
 #if defined(__linux__)
 .section .note.GNU-stack,"",@progbits
diff --git a/runtime/src/z_Linux_util.c b/runtime/src/z_Linux_util.c
index 7633f99..348f5d8 100644
--- a/runtime/src/z_Linux_util.c
+++ b/runtime/src/z_Linux_util.c
@@ -32,7 +32,7 @@
 #include <sys/resource.h>
 #include <sys/syscall.h>
 
-#if KMP_OS_LINUX
+#if KMP_OS_LINUX && !KMP_OS_CNK
 # include <sys/sysinfo.h>
 # if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
 // We should really include <futex.h>, but that causes compatibility problems on different
@@ -61,7 +61,7 @@
 #include <fcntl.h>
 
 // For non-x86 architecture
-#if KMP_COMPILER_GCC && !(KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_COMPILER_GCC && !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_PPC64)
 # include <stdbool.h>
 # include <ffi.h>
 #endif
@@ -110,7 +110,7 @@
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
-#if KMP_OS_LINUX && KMP_AFFINITY_SUPPORTED
+#if ( KMP_OS_LINUX && KMP_AFFINITY_SUPPORTED)
 
 /*
  * Affinity support
@@ -147,6 +147,19 @@
 #    error Wrong code for getaffinity system call.
 #   endif /* __NR_sched_getaffinity */
 
+#  elif KMP_ARCH_PPC64
+#   ifndef __NR_sched_setaffinity
+#    define __NR_sched_setaffinity  222
+#   elif __NR_sched_setaffinity != 222
+#    error Wrong code for setaffinity system call.
+#   endif /* __NR_sched_setaffinity */
+#   ifndef __NR_sched_getaffinity
+#    define __NR_sched_getaffinity  223
+#   elif __NR_sched_getaffinity != 223
+#    error Wrong code for getaffinity system call.
+#   endif /* __NR_sched_getaffinity */
+
+
 #  else
 #   error Unknown or unsupported architecture
 
@@ -445,7 +458,7 @@
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
+#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM) && !KMP_OS_CNK
 
 int
 __kmp_futex_determine_capable()
@@ -462,7 +475,7 @@
     return retval;
 }
 
-#endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
+#endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM) && !KMP_OS_CNK
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
@@ -481,7 +494,7 @@
     old_value = TCR_4( *p );
     new_value = old_value | d;
 
-    while ( ! __kmp_compare_and_store32 ( p, old_value, new_value ) )
+    while ( ! KMP_COMPARE_AND_STORE_REL32 ( p, old_value, new_value ) )
     {
         KMP_CPU_PAUSE();
         old_value = TCR_4( *p );
@@ -498,7 +511,7 @@
     old_value = TCR_4( *p );
     new_value = old_value & d;
 
-    while ( ! __kmp_compare_and_store32 ( p, old_value, new_value ) )
+    while ( ! KMP_COMPARE_AND_STORE_REL32 ( p, old_value, new_value ) )
     {
         KMP_CPU_PAUSE();
         old_value = TCR_4( *p );
@@ -507,7 +520,7 @@
     return old_value;
 }
 
-# if KMP_ARCH_X86
+# if KMP_ARCH_X86 || KMP_ARCH_PPC64
 kmp_int64
 __kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 d )
 {
@@ -516,7 +529,7 @@
     old_value = TCR_8( *p );
     new_value = old_value + d;
 
-    while ( ! __kmp_compare_and_store64 ( p, old_value, new_value ) )
+    while ( ! KMP_COMPARE_AND_STORE_REL64 ( p, old_value, new_value ) )
     {
         KMP_CPU_PAUSE();
         old_value = TCR_8( *p );
@@ -533,7 +546,7 @@
 
     old_value = TCR_8( *p );
     new_value = old_value | d;
-    while ( ! __kmp_compare_and_store64 ( p, old_value, new_value ) )
+    while ( ! KMP_COMPARE_AND_STORE_REL64 ( p, old_value, new_value ) )
     {
         KMP_CPU_PAUSE();
         old_value = TCR_8( *p );
@@ -549,7 +562,7 @@
 
     old_value = TCR_8( *p );
     new_value = old_value & d;
-    while ( ! __kmp_compare_and_store64 ( p, old_value, new_value ) )
+    while ( ! KMP_COMPARE_AND_STORE_REL64 ( p, old_value, new_value ) )
     {
         KMP_CPU_PAUSE();
         old_value = TCR_8( *p );
@@ -2527,7 +2540,7 @@
 #endif // USE_LOAD_BALANCE
 
 
-#if KMP_COMPILER_GCC && !(KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_COMPILER_GCC && !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_PPC64)
 
 int __kmp_invoke_microtask( microtask_t pkfn, int gtid, int tid, int argc,
         void *p_argv[] )
@@ -2561,7 +2574,89 @@
     return 1;
 }
 
-#endif // KMP_COMPILER_GCC && !(KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#endif // KMP_COMPILER_GCC && !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_PPC64)
+
+#if KMP_ARCH_PPC64
+
+// we really only need the case with 1 argument, because CLANG always build
+// a struct of pointers to shared variables referenced in the outlined function
+int
+__kmp_invoke_microtask( microtask_t pkfn,
+                        int gtid, int tid,
+                        int argc, void *p_argv[] ) {
+  switch (argc) {
+  default:
+    fprintf(stderr, "Too many args to microtask: %d!\n", argc);
+    fflush(stderr);
+    exit(-1);
+  case 0:
+    (*pkfn)(&gtid, &tid);
+    break;
+  case 1:
+    (*pkfn)(&gtid, &tid, p_argv[0]);
+    break;
+  case 2:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1]);
+    break;
+  case 3:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2]);
+    break;
+  case 4:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3]);
+    break;
+  case 5:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4]);
+    break;
+  case 6:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5]);
+    break;
+  case 7:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6]);
+    break;
+  case 8:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7]);
+    break;
+  case 9:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8]);
+    break;
+  case 10:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9]);
+    break;
+  case 11:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10]);
+    break;
+  case 12:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
+            p_argv[11]);
+    break;
+  case 13:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
+            p_argv[11], p_argv[12]);
+    break;
+  case 14:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
+            p_argv[11], p_argv[12], p_argv[13]);
+    break;
+  case 15:
+    (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
+            p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
+            p_argv[11], p_argv[12], p_argv[13], p_argv[14]);
+    break;
+  }
+
+  return 1;
+}
+
+#endif
 
 // end of file //
 
diff --git a/runtime/tools/lib/Platform.pm b/runtime/tools/lib/Platform.pm
index 5b399f7..077e649 100644
--- a/runtime/tools/lib/Platform.pm
+++ b/runtime/tools/lib/Platform.pm
@@ -50,6 +50,8 @@
             $arch = "32e";
         } elsif ( $arch =~ m{\Aarm(?:v7\D*)?\z} ) {
             $arch = "arm";
+        } elsif ( $arch =~ m{\Appc64} ) {
+        	$arch = "ppc64";            
         } else {
             $arch = undef;
         }; # if
@@ -159,6 +161,8 @@
         $_host_arch = "32e";
     } elsif ( $hardware_platform eq "arm" ) {
         $_host_arch = "arm";
+    } elsif ( $hardware_platform eq "ppc64" ) {
+        $_host_arch = "ppc64";
     } else {
         die "Unsupported host hardware platform: \"$hardware_platform\"; stopped";
     }; # if
diff --git a/runtime/tools/lib/Uname.pm b/runtime/tools/lib/Uname.pm
index e212501..52518b4 100644
--- a/runtime/tools/lib/Uname.pm
+++ b/runtime/tools/lib/Uname.pm
@@ -147,6 +147,8 @@
         $values{ hardware_platform } = "x86_64";
     } elsif ( $values{ machine } =~ m{\Aarmv7\D*\z} ) {
         $values{ hardware_platform } = "arm";
+    } elsif ( $values{ machine } =~ m{\Appc64\z} ) {
+        $values{ hardware_platform } = "ppc64";
     } else {
         die "Unsupported machine (\"$values{ machine }\") returned by POSIX::uname(); stopped";
     }; # if
diff --git a/runtime/tools/src/common-defs.mk b/runtime/tools/src/common-defs.mk
index ebd1922..7eb64b0 100644
--- a/runtime/tools/src/common-defs.mk
+++ b/runtime/tools/src/common-defs.mk
@@ -45,7 +45,7 @@
 # Description:
 #     The function return printable name of specified architecture, IA-32 architecture or Intel(R) 64.
 #
-legal_arch = $(if $(filter 32,$(1)),IA-32,$(if $(filter 32e,$(1)),Intel(R) 64,$(if $(filter l1,$(1)),L1OM,$(if $(filter arm,$(1)),ARM,$(error Bad architecture specified: $(1))))))
+legal_arch = $(if $(filter 32,$(1)),IA-32,$(if $(filter 32e,$(1)),Intel(R) 64,$(if $(filter l1,$(1)),L1OM,$(if $(filter arm,$(1)),ARM,$(if $(filter ppc64,$(1)),PPC64,$(error Bad architecture specified: $(1)))))))
 
 # Synopsis:
 #     var_name = $(call check_variable,var,list)
@@ -128,9 +128,9 @@
 # --------------------------------------------------------------------------------------------------
 
 os       := $(call check_variable,os,lin lrb mac win)
-arch     := $(call check_variable,arch,32 32e 64 arm)
+arch     := $(call check_variable,arch,32 32e 64 arm ppc64)
 platform := $(os)_$(arch)
-platform := $(call check_variable,platform,lin_32 lin_32e lin_64 lin_arm lrb_32e mac_32 mac_32e win_32 win_32e win_64)
+platform := $(call check_variable,platform,lin_32 lin_32e lin_64 lin_arm lrb_32e mac_32 mac_32e win_32 win_32e win_64 lin_ppc64)
 # oa-opts means "os and arch options". They are passed to almost all perl scripts.
 oa-opts  := --os=$(os) --arch=$(arch)