Moving rocm-build to the tools folder (#3285)

[Why]
To maintain the "pitchfork layout" convention used by the repository.

[How]
- Update README.md
- Update INFRA_REPO in ROCm.mk
   - Updated to new path: ROCm/tools/rocm-build

---------

Signed-off-by: David Galiffi <David.Galiffi@amd.com>

tools/rocm-build/README.md

@@ -0,0 +1,37 @@
+# Overview for ROCm.mk
+
+This Makefile builds the various projects that makes up ROCm in the correct order.
+It is expected to be run in an environment with the tooling set up. An easy way
+to do this is to use Docker.
+
+## Targets
+
+* all (default)
+* rocm-dev (a subset of all)
+* clean
+* list_components
+* help
+* T_foo
+* C_foo
+
+## Makefile Variables
+
+* PEVAL set to 1 to enable some Makefile debugging code.
+* RELEASE\_FLAG set to "" to avoid passing "-r" to builds, effect is package defined.
+* NOBUILD="foo bar" to avoid adding foo and bar into the dependencies of top level targets. They still may be
+  built if they are needed as dependencies of other top level targets.
+* toplevel
+
+## Makefile assumptions
+
+### Requirements for package "foo"
+
+#### program build\_foo.sh
+
+* Should take option "-c" to clean
+* Should take option "-r" to do a normal "RelWithDeb" build
+
+### For package "foo" we define some targets
+
+* T\_foo - The main build target, calls "build\_foo.sh -r"
+* C\_foo - Clean target, calls "build_foo.sh -c"

tools/rocm-build/ROCm.mk

@@ -0,0 +1,248 @@
+# Traditional first make target
+all:
+
+# Use bash as a shell
+# On Ubuntu sh is 'dash'
+SHELL:=bash
+
+# Allow RELEASE_FLAG to be overwritten
+RELEASE_FLAG?=-r
+
+# Set SANITIZER_FLAG for sanitizer
+ASAN_DEP:=
+ifeq (${ENABLE_ADDRESS_SANITIZER},true)
+	ASAN_DEP=lightning
+	SANITIZER_FLAG=-a
+endif
+
+export INFRA_REPO:=ROCm/tools/rocm-build
+
+OUT_DIR:=$(shell . ${INFRA_REPO}/envsetup.sh >/dev/null 2>&1 ; echo $${OUT_DIR})
+ROCM_INSTALL_PATH:=$(shell . ${INFRA_REPO}/envsetup.sh >/dev/null 2>&1 ; echo $${ROCM_INSTALL_PATH})
+
+$(info OUT_DIR=${OUT_DIR})
+$(info ROCM_INSTALL_PATH=${ROCM_INSTALL_PATH})
+
+# -------------------------------------------------------------------------
+# Internal stuff. Could be put in a different file to hide it.
+# Internal macros, they need to be defined before being used.
+
+# The internal "eval" allows parts of the Makefile to be generated.
+# Whilst it is possible to dump the effective Makefile, it can be
+# hard to see where parts come from. Set up the "peval" macro which
+# optionally prints out the generated makefile snippet and evaluate it.
+# Use "make PEVAL=1 all" to see the things being evaluated.
+ifeq (,${PEVAL})
+    define peval =
+    $(eval $1)
+    endef
+else
+    define peval =
+    $(eval $(info $1)$1)
+    endef
+endif
+
+# macro to add dependencies. Saves having to put all the OUT_DIR/logs in
+# The outer strip is to work around a gnu make 4.1 and earlier bug
+# It should not be needed.
+define adddep =
+$(strip $(call peval,components+= $(1) $(2))
+$(foreach comp,$(strip $2),$(call peval,${OUT_DIR}/logs/${1}: ${OUT_DIR}/logs/${comp}))
+)
+endef
+# End of internal stuff that is needed at the start of the file
+# -------------------------------------------------------------------------
+
+# Dependencies. These can be updated. Anything that is mentioned in
+# either the args to the adddep macro will be added to components.  as
+# an example there is no need for the adddep of lightning, as it
+# depends on nothing and at least one other component includes it.
+
+# Syntax. Up to the first comma everything is fixed. The "call" is a
+# keyword to gnu make. The "adddep" is the name of the variable containing
+# the macro.
+# The second comma delimited argument is the target.
+# The third comma delimited arg is the thing that the target depends on.
+# It is a space seperated list with zero or more elements.
+
+$(call adddep,amd_smi_lib,${ASAN_DEP})
+$(call adddep,aqlprofile,${ASAN_DEP} hsa)
+$(call adddep,clang-ocl,lightning rocm-cmake)
+$(call adddep,comgr,lightning devicelibs)
+$(call adddep,dbgapi,hsa comgr)
+$(call adddep,devicelibs,lightning)
+$(call adddep,hip_on_rocclr,${ASAN_DEP} rocclr rocprofiler-register)
+$(call adddep,hipcc,)
+$(call adddep,hipify_clang,hip_on_rocclr lightning)
+$(call adddep,hsa,${ASAN_DEP} thunk lightning devicelibs rocprofiler-register)
+$(call adddep,lightning,)
+$(call adddep,opencl_on_rocclr,${ASAN_DEP} rocclr)
+$(call adddep,openmp_extras,thunk lightning devicelibs hsa)
+$(call adddep,rdc,${ASAN_DEP} rocm_smi_lib hsa rocprofiler)
+$(call adddep,rocclr,${ASAN_DEP} hsa comgr hipcc rocprofiler-register)
+$(call adddep,rocm_bandwidth_test,${ASAN_DEP} hsa)
+$(call adddep,rocm_smi_lib,${ASAN_DEP})
+$(call adddep,rocm-cmake,${ASAN_DEP})
+$(call adddep,rocm-core,${ASAN_DEP})
+$(call adddep,rocm-gdb,dbgapi)
+$(call adddep,rocminfo,${ASAN_DEP} hsa)
+$(call adddep,rocprofiler-register,${ASAN_DEP})
+$(call adddep,rocprofiler,${ASAN_DEP} hsa roctracer aqlprofile opencl_on_rocclr hip_on_rocclr comgr dbgapi rocm_smi_lib)
+$(call adddep,rocr_debug_agent,${ASAN_DEP} hip_on_rocclr hsa dbgapi)
+$(call adddep,roctracer,${ASAN_DEP} hsa hip_on_rocclr)
+$(call adddep,thunk,${ASAN_DEP})
+
+# rocm-dev points to all possible last finish components of Stage1 build.
+rocm-dev-components :=rdc hipify_clang openmp_extras \
+	rocm-core amd_smi_lib hipcc clang-ocl \
+	rocm_bandwidth_test rocr_debug_agent rocm-gdb
+$(call adddep,rocm-dev,$(filter-out ${NOBUILD},${rocm-dev-components}))
+
+$(call adddep,amdmigraphx,hip_on_rocclr half rocblas miopen-hip lightning hipcc)
+$(call adddep,composable_kernel,lightning hipcc hip_on_rocclr rocm-cmake)
+$(call adddep,half,rocm-cmake)
+$(call adddep,hipblas,hip_on_rocclr rocblas rocsolver lightning hipcc)
+$(call adddep,hipblaslt,hip_on_rocclr openmp_extras hipblas lightning hipcc)
+$(call adddep,hipcub,hip_on_rocclr rocprim lightning hipcc)
+$(call adddep,hipfft,hip_on_rocclr openmp_extras rocfft rocrand hiprand lightning hipcc)
+$(call adddep,hipfort,rocblas hipblas rocsparse hipsparse rocfft hipfft rocrand hiprand rocsolver hipsolver lightning hipcc)
+$(call adddep,hiprand,hip_on_rocclr rocrand lightning hipcc)
+$(call adddep,hipsolver,hip_on_rocclr rocblas rocsolver rocsparse lightning hipcc hipsparse)
+$(call adddep,hipsparse,hip_on_rocclr rocsparse lightning hipcc)
+$(call adddep,hipsparselt,hip_on_rocclr hipsparse lightning hipcc openmp_extras)
+$(call adddep,hiptensor,hip_on_rocclr composable_kernel lightning hipcc)
+$(call adddep,miopen-deps,lightning hipcc)
+$(call adddep,miopen-hip,composable_kernel half hip_on_rocclr miopen-deps rocblas roctracer lightning hipcc)
+$(call adddep,mivisionx,amdmigraphx miopen-hip rpp lightning hipcc)
+$(call adddep,rccl,hip_on_rocclr hsa lightning hipcc rocm_smi_lib hipify_clang)
+$(call adddep,rocalution,rocblas rocsparse rocrand lightning hipcc)
+$(call adddep,rocblas,hip_on_rocclr openmp_extras lightning hipcc)
+$(call adddep,rocdecode,hip_on_rocclr lightning hipcc)
+$(call adddep,rocfft,hip_on_rocclr rocrand hiprand lightning hipcc openmp_extras)
+$(call adddep,rocmvalidationsuite,hip_on_rocclr hsa rocblas rocm-core lightning hipcc rocm_smi_lib)
+$(call adddep,rocprim,hip_on_rocclr lightning hipcc)
+$(call adddep,rocrand,hip_on_rocclr lightning hipcc)
+$(call adddep,rocsolver,hip_on_rocclr rocblas rocsparse lightning hipcc)
+$(call adddep,rocsparse,hip_on_rocclr rocprim lightning hipcc)
+$(call adddep,rocthrust,hip_on_rocclr rocprim lightning hipcc)
+$(call adddep,rocwmma,hip_on_rocclr rocblas lightning hipcc rocm-cmake rocm_smi_lib)
+$(call adddep,rpp,half lightning hipcc openmp_extras)
+
+
+# -------------------------------------------------------------------------
+# The rest of the file is internal
+# Do not pass jobserver params if -n build
+ifneq (,$(findstring n,${MAKEFLAGS}))
+RMAKE:=
+else
+RMAKE := +
+endif
+
+
+# disable the builtin rules
+.SUFFIXES:
+
+# Linear
+# include moredeps
+
+# A macro to define a toplevel target, add it to the 'all' target
+# Make it depend on the generated log. Generate the log of the build.
+
+# See if the macro is already defined, if so don't touch it.
+# As GNU make allows more than one makefile to be specified with "-f"
+# one could put an alternative definition of "toplevel" in a different
+# file or even the environment, and use the data in this file for other
+# purposes. Uses might include generating output in "dot" format for
+# showing the dependency graph, or having a wrapper script to run programs
+# to generate code quality tools.
+ifeq (${toplevel},)
+# { Start of test to see if toplevel is defined
+define toplevel =
+
+# The "target" make, this builds the package if it is out of date
+T_$1: ${OUT_DIR}/logs/$1 FRC
+	:              $1 built
+
+# The "upload" for $1, it uploads the packages for $1 to the central storage
+U_$1: T_$1 FRC
+	source $${INFRA_REPO}/envsetup.sh && $${INFRA_REPO}/upload_packages.sh "$1"
+	:		$1 uploaded
+
+# The "clean" for $1, it just marks the target as not existing so it will be built
+# in the future.
+C_$1: FRC
+	rm -f ${OUT_DIR}/logs/$1 ${OUT_DIR}/logs/$1.repackaged
+
+# parallel build {
+${OUT_DIR}/logs/$1: | ${OUT_DIR}/logs
+ifneq ($(wildcard ${OUT_DIR}/logs/$1.repackaged),)
+	@echo  Skipping build of $1 as it has already been repackaged
+	cat $$@.repackaged > $$@
+	rm -f $$@.repackaged
+else # } {
+	@echo  $1 started due to $$? | sed "s:${OUT_DIR}/logs/::g"
+# Build in a subshell so we get the time output
+# Pass in jobserver info using the RMAKE variable
+	${RMAKE}@( if set -x && source $${INFRA_REPO}/envsetup.sh && \
+	rm -f $$@.errors $$@ $$@.repackaged && \
+	$${INFRA_REPO}/build_$1.sh -c && source $${INFRA_REPO}/ccache-env-mathlib.sh && \
+	time bash -x $${INFRA_REPO}/build_$1.sh $${RELEASE_FLAG} $${SANITIZER_FLAG} && $${INFRA_REPO}/post_inst_pkg.sh "$1" ; \
+	then mv $$@.inprogress $$@ ; \
+	else mv $$@.inprogress $$@.errors ; echo Error in $1 >&2 ; exit 1 ;\
+	fi ) > $$@.inprogress 2>&1
+endif # }
+
+# end of toplevel macro
+endef
+# } End of test to see if toplevel is defined
+endif
+
+components:=$(sort $(components))
+
+# Create all the T_xxxx and C_xxxx targets
+$(call peval,$(foreach dep,$(strip ${components}),$(call toplevel,${dep})))
+
+# Add all the T_xxxx targets to "all"  except those listed in NOBUILD
+# Note this does not prohibit them from being built, it just means that
+# a build of "all" will not force them to be built directly
+# example command
+#  make -f jenkins-utils/scripts/Stage1.mk -j60
+
+##help all: Build everything
+all: $(addprefix T_,$(filter-out ${NOBUILD},${components}))
+	@echo All ROCm components built
+# Do not document this target
+upload: $(addprefix U_,${components})
+	@echo All ROCm components built and uploaded
+
+##help rocm-dev: Build a subset of ROCm
+rocm-dev: T_rocm-dev
+	@echo rocm-dev built
+
+${OUT_DIR}/logs:
+	sudo mkdir -p -m 775 "${ROCM_INSTALL_PATH}" && \
+	sudo chown -R "$(shell id -u):$(shell id -g)" "${ROCM_INSTALL_PATH}"
+	sudo chown -R "$(shell id -u):$(shell id -g)" "/home/$(shell id -un)"
+	mkdir -p "${@}"
+	mkdir -p ${HOME}/.ccache
+
+##help clean: remove the output directory and recreate it
+clean:
+	[ -n "${OUT_DIR}" ] && rm -rf "${OUT_DIR}"
+	mkdir -p ${OUT_DIR}/logs
+
+.SECONDARY: ${components:%=${OUT_DIR}/logs/%}
+
+.PHONY: all clean repack help list_components
+
+##help list_components: output the list of components
+##help : Hint make list_components | paste - - - | column -t
+list_components:
+	@echo "${components}" | sed 'y/ /\n/'
+
+##help help:	show this text
+help:
+	@sed -n 's/^##help //p' ${MAKEFILE_LIST} | \
+	    if type -t column > /dev/null ; then  column -s: -t ; else cat ; fi
+
+FRC:

tools/rocm-build/build_amd_smi_lib.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [-c|-r|-h] [makeopts]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Removes all amd_smi build artifacts"
+    echo "  -r,  --release            Build non-debug version amd_smi (default is debug)"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of type referred to by pkg_type"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -h,  --help               Prints this help"
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+PACKAGE_ROOT="$(getPackageRoot)"
+TARGET="build"
+
+PACKAGE_LIB=$(getLibPath)
+PACKAGE_INCLUDE="$(getIncludePath)"
+
+AMDSMI_BUILD_DIR=$(getBuildPath amdsmi)
+AMDSMI_PACKAGE_DEB_DIR="$(getPackageRoot)/deb/amdsmi"
+AMDSMI_PACKAGE_RPM_DIR="$(getPackageRoot)/rpm/amdsmi"
+AMDSMI_BUILD_TYPE="debug"
+BUILD_TYPE="Debug"
+
+MAKETARGET="deb"
+MAKEARG="$DASH_JAY O=$AMDSMI_BUILD_DIR"
+AMDSMI_MAKE_OPTS="$DASH_JAY O=$AMDSMI_BUILD_DIR -C $AMDSMI_BUILD_DIR"
+AMDSMI_PKG_NAME="amd-smi-lib"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+PKGTYPE="deb"
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on
+                # TODO - support standard option of passing cmake environment vars - CFLAGS,CXXFLAGS etc., to enable address sanitizer
+                ADDRESS_SANITIZER=true ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;; # end delimiter
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_amdsmi() {
+    rm -rf "$AMDSMI_BUILD_DIR"
+    rm -rf "$AMDSMI_PACKAGE_DEB_DIR"
+    rm -rf "$AMDSMI_PACKAGE_RPM_DIR"
+    rm -rf "$PACKAGE_ROOT/amd_smi"
+    rm -rf "$PACKAGE_INCLUDE/amd_smi"
+    rm -f $PACKAGE_LIB/libamd_smi.*
+    return 0
+}
+
+build_amdsmi() {
+    echo "Building AMDSMI"
+    echo "AMDSMI_BUILD_DIR: ${AMDSMI_BUILD_DIR}"
+    if [ ! -d "$AMDSMI_BUILD_DIR" ]; then
+        mkdir -p $AMDSMI_BUILD_DIR
+        pushd $AMDSMI_BUILD_DIR
+        print_lib_type $SHARED_LIBS
+        cmake \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            $(rocm_common_cmake_params) \
+            $(rocm_cmake_params) \
+            -DENABLE_LDCONFIG=OFF \
+            -DAMD_SMI_PACKAGE="${AMDSMI_PKG_NAME}" \
+            -DCPACK_PACKAGE_VERSION_MAJOR="1" \
+            -DCPACK_PACKAGE_VERSION_MINOR="$ROCM_LIBPATCH_VERSION" \
+            -DCPACK_PACKAGE_VERSION_PATCH="0" \
+            -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+            -DBUILD_TESTS=ON \
+            "$AMD_SMI_LIB_ROOT"
+        popd
+    fi
+
+    echo "Making amd_smi package:"
+    cmake --build "$AMDSMI_BUILD_DIR" -- $AMDSMI_MAKE_OPTS
+    cmake --build "$AMDSMI_BUILD_DIR" -- $AMDSMI_MAKE_OPTS install
+    cmake --build "$AMDSMI_BUILD_DIR" -- $AMDSMI_MAKE_OPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$AMDSMI_PACKAGE_DEB_DIR" $AMDSMI_BUILD_DIR/*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$AMDSMI_PACKAGE_RPM_DIR" $AMDSMI_BUILD_DIR/*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${AMDSMI_PACKAGE_DEB_DIR};;
+        ("rpm")
+            echo ${AMDSMI_PACKAGE_RPM_DIR};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean_amdsmi ;;
+    (build) build_amdsmi ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"
+exit 0

tools/rocm-build/build_amdmigraphx.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src AMDMIGraphX
+
+build_amdmigraphx() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    pip3 install https://github.com/RadeonOpenCompute/rbuild/archive/master.tar.gz
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+    fi
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    mkdir -p ${BUILD_DIR} && rm -rf ${BUILD_DIR}/* && mkdir -p ${HOME}/amdmigraphx && rm -rf ${HOME}/amdmigraphx/*
+    rbuild package -d "${HOME}/amdmigraphx" -B "${BUILD_DIR}" \
+        --cxx="${ROCM_PATH}/llvm/bin/clang++" \
+        --cc="${ROCM_PATH}/llvm/bin/clang" \
+        $(rocm_common_cmake_params) \
+        -DCMAKE_MODULE_LINKER_FLAGS="-Wl,--enable-new-dtags -Wl,--rpath,$ROCM_LIB_RPATH" \
+	    -DGPU_TARGETS="${GPU_TARGETS}" \
+        -DCMAKE_INSTALL_RPATH=""
+
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+    cd $BUILD_DIR && cmake --build . -- install -j${PROC}
+
+    show_build_cache_stats
+}
+
+clean_amdmigraphx() {
+    echo "Cleaning AMDMIGraphX build directory: ${BUILD_DIR} ${DEPS_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$DEPS_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_amdmigraphx ;;
+    outdir) print_output_directory ;;
+    clean) clean_amdmigraphx ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_aqlprofile.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: ${BASH_SOURCE##*/} [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+            type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+API_NAME="hsa-amd-aqlprofile"
+PACKAGE_DEB="$(getPackageRoot)/deb/$API_NAME"
+PROJ_NAME="$API_NAME"
+TARGET="build"
+BUILD_TYPE="Debug"
+MAKETARGET="deb"
+MAKE_OPTS="$DASH_JAY -C $BUILD_DIR"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+VALID_STR=$(getopt -o hcro:p: --long help,clean,release,clean,outdir:,package: -- "$@")
+eval set -- "$VALID_STR"
+
+while true; do
+    case "$1" in
+    -h | --help)
+        printUsage
+        exit 0
+        ;;
+    -c | --clean)
+        TARGET="clean"
+        ((CLEAN_OR_OUT |= 1))
+        shift
+        ;;
+    -r | --release)
+        BUILD_TYPE="Release"
+        shift
+        ;;
+    -o | --outdir)
+        TARGET="outdir"
+        PKGTYPE=$2
+        OUT_DIR_SPECIFIED=1
+        ((CLEAN_OR_OUT |= 2))
+        shift 2
+        ;;
+    --)
+        shift
+        break
+        ;;
+    *)
+        echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] " >&2
+        exit 20
+        ;;
+    esac
+
+done
+
+copy_pkg_files_to_rocm() {
+    local comp_folder=$1
+    local comp_pkg_name=$2
+
+    cd "${OUT_DIR}/${PKGTYPE}/${comp_folder}"|| exit 2
+    if [ "${PKGTYPE}" = 'deb' ]; then
+        dpkg-deb -x ${comp_pkg_name}_*.deb pkg/
+    else
+        mkdir pkg && pushd pkg/ || exit 2
+        if [[ "${comp_pkg_name}" != *-dev* ]]; then
+            rpm2cpio ../${comp_pkg_name}-*.rpm | cpio -idmv
+        else
+            rpm2cpio ../${comp_pkg_name}el-*.rpm | cpio -idmv
+        fi
+        popd || exit 2
+    fi
+    ls ./pkg -alt
+    sudo cp -r ./pkg/*/rocm*/* "${ROCM_PATH}" || exit 2
+    rm -rf pkg/
+}
+
+clean() {
+    echo "Cleaning $PROJ_NAME package"
+    rm -rf "$PACKAGE_DEB"
+}
+
+build() {
+    echo "Downloading $PROJ_NAME" package
+    if [ "$DISTRO_NAME" = ubuntu ]; then
+        mkdir -p "$PACKAGE_DEB"
+        local rocm_ver=${ROCM_VERSION}
+        if [ ${ROCM_VERSION##*.} = 0 ]; then
+            rocm_ver=${ROCM_VERSION%.*}
+        fi
+        local url="https://repo.radeon.com/rocm/apt/${rocm_ver}/pool/main/h/${API_NAME}/"
+        local package
+        package=$(curl -s "$url" | grep -Po 'href="\K[^"]*' | grep "${DISTRO_RELEASE}" | head -n 1)
+
+        if [ -z "$package" ]; then
+            echo "No package found for Ubuntu version $DISTRO_RELEASE"
+            exit 1
+        fi
+
+        wget -t3 -P "$PACKAGE_DEB" "${url}${package}"
+        copy_pkg_files_to_rocm ${API_NAME} ${API_NAME}
+    else
+        echo "$DISTRO_ID is not supported..."
+        exit 2
+    fi
+
+    echo "Installing $PROJ_NAME" package
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+    "deb")
+        echo ${PACKAGE_DEB}
+        ;;
+    "rpm")
+        echo ${PACKAGE_RPM}
+        ;;
+    *)
+        echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2
+        exit 1
+        ;;
+    esac
+    exit
+}
+
+case "$TARGET" in
+clean) clean ;;
+build) build ;;
+outdir) print_output_directory ;;
+*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_clang-ocl.sh

@@ -0,0 +1,136 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [-c|-r|-h] [makeopts]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Removes all clang-ocl build artifacts"
+    echo "  -r,  --release            Build non-debug version clang-ocl (default is debug)"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+                                      type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo
+
+    return 0
+}
+
+
+TARGET="build"
+CLANG_OCL_DEST="$(getBinPath)"
+CLANG_OCL_SRC_ROOT="$CLANG_OCL_ROOT"
+CLANG_OCL_BUILD_DIR="$(getBuildPath clang-ocl)"
+
+MAKEARG="$DASH_JAY"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_UTILS="$(getUtilsPath)"
+CLANG_OCL_PACKAGE_DEB="$PACKAGE_ROOT/deb/clang-ocl"
+CLANG_OCL_PACKAGE_RPM="$PACKAGE_ROOT/rpm/clang-ocl"
+BUILD_TYPE="Debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso:g: --long help,clean,release,clean,static,address_sanitizer,outdir:,gpu_list: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                MAKEARG="$MAKEARG BUILD_TYPE=rel" ;  BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-g | --gpu_list )
+                GPU_LIST=$2; shift 2 ;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_clang-ocl() {
+    echo "Removing clang-ocl"
+    rm -rf $CLANG_OCL_DEST/clang-ocl
+    rm -rf $CLANG_OCL_BUILD_DIR
+    rm -rf $CLANG_OCL_PACKAGE_DEB
+    rm -rf $CLANG_OCL_PACKAGE_RPM
+}
+
+build_clang-ocl() {
+    if [ ! -d "$CLANG_OCL_BUILD_DIR" ]; then
+        mkdir -p $CLANG_OCL_BUILD_DIR
+        pushd $CLANG_OCL_BUILD_DIR
+
+        if [ -e $PACKAGE_ROOT/lib/bitcode/opencl.amdgcn.bc ]; then
+            BC_DIR="$ROCM_INSTALL_PATH/lib"
+        else
+            BC_DIR="$ROCM_INSTALL_PATH/amdgcn/bitcode"
+        fi
+
+        cmake \
+            $(rocm_cmake_params) \
+            -DDISABLE_CHECKS="ON" \
+            -DCLANG_BIN="$ROCM_INSTALL_PATH/llvm/bin" \
+            -DBITCODE_DIR="$BC_DIR" \
+	    $(rocm_common_cmake_params) \
+            -DCPACK_SET_DESTDIR="OFF" \
+            $CLANG_OCL_SRC_ROOT
+
+        echo "Making clang-ocl:"
+        cmake --build . -- $MAKEARG
+        cmake --build . -- $MAKEARG install
+        cmake --build . -- $MAKEARG package
+        popd
+    fi
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$CLANG_OCL_PACKAGE_DEB" $CLANG_OCL_BUILD_DIR/rocm-clang-ocl*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$CLANG_OCL_PACKAGE_RPM" $CLANG_OCL_BUILD_DIR/rocm-clang-ocl*.rpm
+}
+
+
+print_output_directory() {
+     case ${PKGTYPE} in
+         ("deb")
+             echo ${CLANG_OCL_PACKAGE_DEB};;
+         ("rpm")
+             echo ${CLANG_OCL_PACKAGE_RPM};;
+         (*)
+             echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+     esac
+     exit
+}
+
+case $TARGET in
+    (clean) clean_clang-ocl ;;
+    (build) build_clang-ocl ;;
+   (outdir) print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"
+exit 0
+

tools/rocm-build/build_comgr.sh

@@ -0,0 +1,151 @@
+#!/bin/bash
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+        type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -l,  --link_llvm_static   Link to LLVM statically.  Default is to dynamically link to LLVM; requires that LLVM dylibs are created."
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+API_NAME=amd_comgr
+PROJ_NAME=$API_NAME
+LIB_NAME=lib${API_NAME}
+TARGET=build
+MAKETARGET=deb
+PACKAGE_ROOT=$(getPackageRoot)
+PACKAGE_LIB=$(getLibPath)
+PACKAGE_INCLUDE=$(getIncludePath)
+BUILD_DIR=$(getBuildPath $API_NAME)
+PACKAGE_DEB=$(getPackageRoot)/deb/$API_NAME
+PACKAGE_RPM=$(getPackageRoot)/rpm/$API_NAME
+PACKAGE_PREFIX=$ROCM_INSTALL_PATH
+BUILD_TYPE=Debug
+MAKE_OPTS="$DASH_JAY CTEST_OUTPUT_ON_FAILURE=1 -C $BUILD_DIR"
+VERBOSE_OPTS="AMD_COMGR_EMIT_VERBOSE_LOGS=1 AMD_COMGR_REDIRECT_LOGS=stdout"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+PKGTYPE="deb"
+MAKETARGET="deb"
+
+LINK_LLVM_DYLIB="OFF"
+
+VALID_STR=`getopt -o hcraslo:p: --long help,clean,release,address_sanitizer,static,link_llvm_static,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-l | --link_llvm_static)
+                LINK_LLVM_DYLIB="OFF"; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;; # end delimiter
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+
+    rm -rf $BUILD_DIR
+    rm -rf $PACKAGE_DEB
+    rm -rf $PACKAGE_RPM
+    rm -rf $PACKAGE_ROOT/${PROJ_NAME}
+    rm -rf $PACKAGE_LIB/${LIB_NAME}*
+}
+
+build() {
+    echo "Building $PROJ_NAME"
+
+    mkdir -p "$BUILD_DIR"
+    pushd "$BUILD_DIR"
+    if [ "$SHARED_LIBS" == "OFF" ]
+    then
+       echo " Building Archive "
+    else
+       echo " Building Shared Object "
+    fi
+
+    cmake \
+        $(rocm_cmake_params) \
+        -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+        $(rocm_common_cmake_params) \
+        -DCMAKE_DISABLE_FIND_PACKAGE_hip=TRUE \
+        -DCMAKE_CTEST_ARGUMENTS="--exclude-regex;multithread_test" \
+        -DLLVM_LINK_LLVM_DYLIB=$LINK_LLVM_DYLIB \
+        -DLLVM_ENABLE_LIBCXX=$LINK_LLVM_DYLIB \
+        $COMGR_ROOT
+
+    popd
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS $VERBOSE_OPTS test
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS install
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS package
+
+    mkdir -p $PACKAGE_LIB
+    cp -R $BUILD_DIR/${LIB_NAME}* $PACKAGE_LIB
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" $BUILD_DIR/comgr*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" $BUILD_DIR/comgr*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean ;;
+    (build) build ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_composable_kernel.sh

@@ -0,0 +1,185 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src composable_kernel
+
+build_miopen_ck() {
+    echo "Start Building Composable Kernel"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    cd $COMPONENT_SRC
+    mkdir "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    if [ "${ASAN_CMAKE_PARAMS}" == "true" ] ; then
+        cmake -DBUILD_DEV=OFF \
+            -DCMAKE_BUILD_TYPE=${BUILD_TYPE:-'RelWithDebInfo'} \
+            -DCMAKE_CXX_COMPILER=${ROCM_PATH}/llvm/bin/clang++ \
+            -DCMAKE_CXX_FLAGS=" -O3 " \
+            -DCMAKE_PREFIX_PATH="${ROCM_PATH%-*}/lib/cmake;${ROCM_PATH%-*}/$ASAN_LIBDIR;${ROCM_PATH%-*}/llvm;${ROCM_PATH%-*}" \
+            -DCMAKE_SHARED_LINKER_FLAGS_INIT="-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_LIB_RPATH" \
+            -DCMAKE_EXE_LINKER_FLAGS_INIT="-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_EXE_RPATH" \
+            -DCMAKE_VERBOSE_MAKEFILE=1 \
+            -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=FALSE \
+            -DCMAKE_INSTALL_PREFIX=${ROCM_PATH} \
+            -DCMAKE_PACKAGING_INSTALL_PREFIX=${ROCM_PATH} \
+            -DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+            -DROCM_SYMLINK_LIBS=OFF \
+            -DCPACK_PACKAGING_INSTALL_PREFIX=${ROCM_PATH} \
+            -DROCM_DISABLE_LDCONFIG=ON \
+            -DROCM_PATH=${ROCM_PATH} \
+            -DCPACK_GENERATOR="${PKGTYPE^^}" \
+            ${LAUNCHER_FLAGS} \
+            -DINSTANCES_ONLY=ON \
+            -DENABLE_ASAN_PACKAGING=true \
+            -DAMDGPU_TARGETS=${GPU_TARGETS} \
+            "$COMPONENT_SRC"
+    else
+        cmake -DBUILD_DEV=OFF \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER=${ROCM_PATH}/llvm/bin/clang++ \
+            -DCMAKE_CXX_FLAGS=" -O3 " \
+            -DCMAKE_PREFIX_PATH=${ROCM_PATH%-*} \
+            -DCMAKE_SHARED_LINKER_FLAGS_INIT='-Wl,--enable-new-dtags,--rpath,$ORIGIN' \
+            -DCMAKE_EXE_LINKER_FLAGS_INIT='-Wl,--enable-new-dtags,--rpath,$ORIGIN/../lib' \
+            -DCMAKE_VERBOSE_MAKEFILE=1 \
+            -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=FALSE \
+            -DCMAKE_INSTALL_PREFIX=${ROCM_PATH} \
+            -DCMAKE_PACKAGING_INSTALL_PREFIX=${ROCM_PATH} \
+            -DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+            -DROCM_SYMLINK_LIBS=OFF \
+            -DCPACK_PACKAGING_INSTALL_PREFIX=${ROCM_PATH} \
+            -DROCM_DISABLE_LDCONFIG=ON \
+            -DROCM_PATH=${ROCM_PATH} \
+            -DCPACK_GENERATOR="${PKGTYPE^^}" \
+            ${LAUNCHER_FLAGS} \
+            -DINSTANCES_ONLY=ON \
+            -DAMDGPU_TARGETS=${GPU_TARGETS} \
+            "$COMPONENT_SRC"
+    fi
+
+    cmake --build . -- -j${PROC} package
+    cmake --build "$BUILD_DIR" -- install
+    mkdir -p $PACKAGE_DIR && cp ./*.${PKGTYPE} $PACKAGE_DIR
+    rm -rf *
+}
+
+unset_asan_env_vars() {
+    ASAN_CMAKE_PARAMS="false"
+    export ADDRESS_SANITIZER="OFF"
+    export LD_LIBRARY_PATH=""
+    export ASAN_OPTIONS=""
+}
+
+set_address_sanitizer_off() {
+    export CFLAGS=""
+    export CXXFLAGS=""
+    export LDFLAGS=""
+}
+
+build_miopen_ckProf() {
+    ENABLE_ADDRESS_SANITIZER=false
+    echo "Start Building Composable Kernel Profiler"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    else
+       unset_asan_env_vars
+       set_address_sanitizer_off
+    fi
+
+    cd $COMPONENT_SRC
+    cd "$BUILD_DIR"
+    rm -rf *
+
+    architectures='gfx10 gfx11 gfx90 gfx94'
+    if [ -n "$GPU_ARCHS" ]; then
+        architectures=$(echo ${GPU_ARCHS} | awk -F';' '{for(i=1;i<=NF;i++) a[substr($i,1,5)]} END{for(i in a) printf i" "}')
+    else
+        architectures='gfx10 gfx11 gfx90 gfx94'
+    fi
+
+    for arch in ${architectures}
+        do
+            if [ "${ASAN_CMAKE_PARAMS}" == "true" ] ; then
+                cmake -DBUILD_DEV=OFF \
+                    -DCMAKE_PREFIX_PATH="${ROCM_PATH%-*}/lib/cmake;${ROCM_PATH%-*}/$ASAN_LIBDIR;${ROCM_PATH%-*}/llvm;${ROCM_PATH%-*}" \
+                    -DCMAKE_BUILD_TYPE=${BUILD_TYPE:-'RelWithDebInfo'} \
+                    -DCMAKE_SHARED_LINKER_FLAGS_INIT="-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_LIB_RPATH" \
+                    -DCMAKE_EXE_LINKER_FLAGS_INIT="-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_EXE_RPATH" \
+                    -DCMAKE_VERBOSE_MAKEFILE=1 \
+                    -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=FALSE \
+                    -DCMAKE_INSTALL_PREFIX="${ROCM_PATH}" \
+                    -DCMAKE_PACKAGING_INSTALL_PREFIX="${ROCM_PATH}" \
+                    -DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+                    -DROCM_SYMLINK_LIBS=OFF \
+                    -DCPACK_PACKAGING_INSTALL_PREFIX="${ROCM_PATH}" \
+                    -DROCM_DISABLE_LDCONFIG=ON \
+                    -DROCM_PATH="${ROCM_PATH}" \
+                    -DCPACK_GENERATOR="${PKGTYPE^^}" \
+                    -DCMAKE_CXX_COMPILER="${ROCM_PATH}/llvm/bin/clang++" \
+                    -DCMAKE_C_COMPILER="${ROCM_PATH}/llvm/bin/clang" \
+                    ${LAUNCHER_FLAGS} \
+                    -DPROFILER_ONLY=ON \
+                    -DENABLE_ASAN_PACKAGING=true \
+                    -DGPU_ARCH="${arch}" \
+                    "$COMPONENT_SRC"
+            else
+                cmake -DBUILD_DEV=OFF \
+                    -DCMAKE_PREFIX_PATH="${ROCM_PATH%-*}" \
+                    -DCMAKE_BUILD_TYPE=Release \
+                    -DCMAKE_SHARED_LINKER_FLAGS_INIT='-Wl,--enable-new-dtags,--rpath,$ORIGIN' \
+                    -DCMAKE_EXE_LINKER_FLAGS_INIT='-Wl,--enable-new-dtags,--rpath,$ORIGIN/../lib' \
+                    -DCMAKE_VERBOSE_MAKEFILE=1 \
+                    -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=FALSE \
+                    -DCMAKE_INSTALL_PREFIX="${ROCM_PATH}" \
+                    -DCMAKE_PACKAGING_INSTALL_PREFIX="${ROCM_PATH}" \
+                    -DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+                    -DROCM_SYMLINK_LIBS=OFF \
+                    -DCPACK_PACKAGING_INSTALL_PREFIX="${ROCM_PATH}" \
+                    -DROCM_DISABLE_LDCONFIG=ON \
+                    -DROCM_PATH="${ROCM_PATH}" \
+                    -DCPACK_GENERATOR="${PKGTYPE^^}" \
+                    -DCMAKE_CXX_COMPILER="${ROCM_PATH}/llvm/bin/clang++" \
+                    -DCMAKE_C_COMPILER="${ROCM_PATH}/llvm/bin/clang" \
+                    ${LAUNCHER_FLAGS} \
+                    -DPROFILER_ONLY=ON \
+                    -DGPU_ARCH="${arch}" \
+                    "$COMPONENT_SRC"
+            fi
+
+            cmake --build . -- -j${PROC} package
+            cp ./*ckprofiler*.${PKGTYPE} $PACKAGE_DIR
+            rm -rf *
+        done
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+
+    echo "Finished building Composable Kernel"
+    show_build_cache_stats
+}
+
+clean_miopen_ck() {
+    echo "Cleaning MIOpen-CK build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_miopen_ck; build_miopen_ckProf;;
+    outdir) print_output_directory ;;
+    clean) clean_miopen_ck ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_dbgapi.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+source "${BASH_SOURCE%/*}/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE[0]}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "       --enable-assertions  Enable assertions"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+            type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -M,  --skip_man_pages     Do not build the 'docs' target"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+API_NAME=rocm-dbgapi
+AMD_DBGAPI_NAME=amd-dbgapi
+MAKEINSTALL_MANIFEST=makeinstall_manifest.txt
+PROJ_NAME=$API_NAME
+LIB_NAME=lib${API_NAME}.so
+TARGET=build
+MAKETARGET=deb
+PACKAGE_ROOT=$(getPackageRoot)
+PACKAGE_LIB=$(getLibPath)
+PACKAGE_INCLUDE=$(getIncludePath)
+BUILD_DIR=$(getBuildPath $API_NAME)
+PACKAGE_DEB=$(getPackageRoot)/deb/$API_NAME
+PACKAGE_RPM=$(getPackageRoot)/rpm/$API_NAME
+BUILD_TYPE=Debug
+MAKE_OPTS=($DASH_JAY -C "$BUILD_DIR")
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+DODOCSBUILD=true
+
+VALID_STR=$(getopt -o hcraso:p:M --long help,clean,release,enable-assertions,static,address_sanitizer,outdir:,package:skip_man_pages -- "$@")
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ;;
+        (-r | --release)
+                ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-"Off"} ;
+                BUILD_TYPE="RelWithDebInfo" ;;
+        ( --enable-assertions)
+                ENABLE_ASSERTIONS="On" ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; ((CLEAN_OR_OUT|=2)) ; shift 1 ;;
+        (-M | --skip_man_pages) DODOCSBUILD=false;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 1;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+    shift
+
+done
+
+check_conflicting_options $CLEAN_OR_OUT "$PKGTYPE" "$MAKETARGET"
+if [ "$RET_CONFLICT" -ge 30 ]; then
+   print_vars "$API_NAME" "$TARGET" "$BUILD_TYPE" "$SHARED_LIBS" "$CLEAN_OR_OUT" "$PKGTYPE" "$MAKETARGET"
+   exit "$RET_CONFLICT"
+fi
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+    if [ -e "$BUILD_DIR/$MAKEINSTALL_MANIFEST" ] ; then
+        xargs rm -f < "$BUILD_DIR/$MAKEINSTALL_MANIFEST"
+    fi
+    rm -rf "$BUILD_DIR"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "${PACKAGE_ROOT:?}/${PROJ_NAME}"
+    rm -rf "${PACKAGE_LIB:?}/${LIB_NAME}"*
+    rm -rf "${PACKAGE_LIB:?}/cmake/${AMD_DBGAPI_NAME}"
+    rm -rf "${PACKAGE_INCLUDE:?}/${AMD_DBGAPI_NAME}"
+}
+
+build() {
+    if [ ! -e "$ROCM_DBGAPI_ROOT/CMakeLists.txt" ]
+    then
+           echo " No $ROCM_DBGAPI_ROOT/CMakeLists.txt file, skipping rocm-dbgapi" >&2
+           echo " No $ROCM_DBGAPI_ROOT/CMakeLists.txt file, skipping rocm-dbgapi"
+       exit 0
+    fi
+    echo "Building $PROJ_NAME"
+
+    mkdir -p "$BUILD_DIR"
+    pushd "$BUILD_DIR" || exit 99
+
+    cmake \
+        $(rocm_cmake_params) \
+        $(rocm_common_cmake_params) \
+        -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-"On"} \
+        "$ROCM_DBGAPI_ROOT"
+
+    popd || exit 99
+    cmake --build "$BUILD_DIR" -- "${MAKE_OPTS[@]}"
+    "$DODOCSBUILD" && cmake --build "$BUILD_DIR" -- "${MAKE_OPTS[@]}" doc
+    cmake --build "$BUILD_DIR" -- "${MAKE_OPTS[@]}" install
+
+    mv "$BUILD_DIR/install_manifest.txt" "$BUILD_DIR/$MAKEINSTALL_MANIFEST"
+    cmake --build "$BUILD_DIR" -- "${MAKE_OPTS[@]}" package
+
+    mkdir -p "$PACKAGE_LIB"
+    (
+        shopt -s nullglob
+        cp -R "$BUILD_DIR/lib/${LIB_NAME}"* "$BUILD_DIR/${LIB_NAME}"* "$PACKAGE_LIB"
+    )
+    
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" "$BUILD_DIR/${API_NAME}"*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" "$BUILD_DIR/${API_NAME}"*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean ;;
+    (build) build ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_devicelibs.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -r,  --release            Build a release version of the package"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -h,  --help             Prints this help"
+    echo
+    echo
+
+    return 0
+}
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_BIN="$(getBinPath)"
+PACKAGE_LIB="$(getLibPath)"
+BUILD_PATH="$(getBuildPath devicelibs)"
+INSTALL_PATH="$(getPackageRoot)"
+LIGHTNING_BUILD_PATH="$(getBuildPath lightning)"
+DEB_PATH="$(getDebPath devicelibs)"
+RPM_PATH="$(getRpmPath devicelibs)"
+AMDGCN_LIB_PATH="$PACKAGE_ROOT/amdgcn/bitcode/"
+
+TARGET="build"
+MAKEOPTS="$DASH_JAY"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+PKGTYPE="deb"
+MAKETARGET="deb"
+
+VALID_STR=`getopt -o hcraso: --long help,clean,release,static,address_sanitizer,outdir: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                ASAN_CMAKE_PARAMS="true"
+                ack_and_ignore_asan ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        --)     shift; break;; # end delimiter
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_devicelibs() {
+    rm -rf "$BUILD_PATH"
+    rm -f $PACKAGE_LIB/hc*.bc
+    rm -f $PACKAGE_LIB/irif*.bc
+    rm -f $PACKAGE_LIB/ockl*.bc
+    rm -f $PACKAGE_LIB/oclc*.bc
+    rm -f $PACKAGE_LIB/ocml*.bc
+    rm -f $PACKAGE_LIB/opencl*.bc
+    rm -f $PACKAGE_LIB/openmp*.bc
+    rm -rf $PACKAGE_ROOT/amdgcn
+    rm -rf "$DEB_PATH"
+    rm -rf "$RPM_PATH"
+}
+
+build_devicelibs() {
+    mkdir -p "$BUILD_PATH"
+    pushd "$BUILD_PATH"
+
+    local clangResourceDir="$($LIGHTNING_BUILD_PATH/bin/clang -print-resource-dir)"
+    local clangResourceVer=${clangResourceDir#*lib/clang/}
+    local bitcodeInstallLoc="lib/llvm/lib/clang/${clangResourceVer}/lib"
+
+    export LLVM_BUILD="$LIGHTNING_BUILD_PATH"
+    if [ ! -e Makefile ]; then
+        cmake $(rocm_cmake_params) \
+              $(rocm_common_cmake_params) \
+              -DROCM_DEVICE_LIBS_BITCODE_INSTALL_LOC_NEW="$bitcodeInstallLoc/amdgcn" \
+              -DROCM_DEVICE_LIBS_BITCODE_INSTALL_LOC_OLD="amdgcn" \
+              "$DEVICELIBS_ROOT"
+
+        echo "CMake complete"
+    fi
+
+    echo "Building device-libs"
+    cmake --build . -- $MAKEOPTS
+    cmake --build . -- $MAKEOPTS install
+    popd
+}
+
+package_devicelibs() {
+    mkdir -p "$DEB_PATH"
+    mkdir -p "$RPM_PATH"
+    pushd "$BUILD_PATH"
+    cpack
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$DEB_PATH" *.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$RPM_PATH" *.rpm 
+    popd
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${DEB_PATH};;
+        ("rpm")
+            echo ${RPM_PATH};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+case $TARGET in
+    (clean) clean_devicelibs ;;
+    (build) build_devicelibs; package_devicelibs ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_half.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src half
+
+build_half() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+         ASAN_CMAKE_PARAMS="false"
+    fi
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    cmake \
+        -DCMAKE_INSTALL_PREFIX="$ROCM_PATH" \
+        -DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- package
+    cmake --build "$BUILD_DIR" -- install
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_half() {
+    echo "Cleaning half build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_half ;;
+    outdir) print_output_directory ;;
+    clean) clean_half ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hip_on_rocclr.sh

@@ -0,0 +1,295 @@
+#!/bin/bash
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -h,  --help                 Prints this help"
+    echo "  -c,  --clean                Clean output and delete all intermediate work"
+    echo "  -r,  --release              Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer    Enable address sanitizer"
+    echo "  -s,  --static               Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -o,  --outdir <pkg_type>    Print path of output directory containing packages of type referred to by pkg_type"
+    echo "  -t,  --offload-arch=<arch>  Specify arch for catch tests ex: --offload-arch=gfx1030 --offload-arch=gfx1100"
+    echo "  -p,  --package <type>       Specify packaging format"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+MAKEOPTS="$DASH_JAY"
+
+BUILD_PATH="$(getBuildPath hip-on-rocclr)"
+
+TARGET="build"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_SRC="$(getSrcPath)"
+PACKAGE_DEB="$PACKAGE_ROOT/deb/hip-on-rocclr"
+PACKAGE_RPM="$PACKAGE_ROOT/rpm/hip-on-rocclr"
+PREFIX_PATH="$PACKAGE_ROOT"
+CORE_BUILD_DIR="$(getBuildPath hsa-core)"
+ROCclr_BUILD_DIR="$(getBuildPath rocclr)"
+HIPCC_BUILD_DIR="$(getBuildPath hipcc)"
+CATCH_BUILD_DIR="$(getBuildPath catch)"
+CATCH_SRC="$HIP_CATCH_TESTS_ROOT/catch"
+SAMPLES_SRC="$HIP_CATCH_TESTS_ROOT/samples"
+SAMPLES_BUILD_DIR="$(getBuildPath samples)"
+if [ ! -e "$CATCH_SRC/CMakeLists.txt" ]; then
+   echo "Using catch source from hip project" >&2
+   CATCH_SRC="$HIP_ON_ROCclr_ROOT/tests/catch"
+fi
+
+BUILD_TYPE="Debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+OFFLOAD_ARCH=()
+
+DEFAULT_OFFLOAD_ARCH=(gfx900 gfx906 gfx908 gfx90a gfx940 gfx941 gfx942 gfx1030 gfx1031 gfx1033 gfx1034 gfx1035 gfx1100 gfx1101 gfx1102 gfx1103)
+
+VALID_STR=`getopt -o hcrast:o: --long help,clean,release,address_sanitizer,static,offload-arch=:,outdir: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-t | --offload-arch=)
+                OFFLOAD_ARCH+=( "$2" ); ((CLEAN_OR_OUT|=2)); shift 2 ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        --)     shift; break;;
+
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+if [ ${#OFFLOAD_ARCH[@]} = 0 ] ; then
+      OFFLOAD_ARCH=( "${DEFAULT_OFFLOAD_ARCH[@]}" )
+else
+    echo "Using user defined offload archs ${OFFLOAD_ARCH[@]} for catch tests";
+fi
+printf -v OFFLOAD_ARCH_STR -- '--offload-arch=%q ' "${OFFLOAD_ARCH[@]}"
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_hip_on_rocclr() {
+    rm -rf "$BUILD_PATH"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "$OUT_DIR/hip"
+}
+
+build_hip_on_rocclr() {
+    if [  -e "$CLR_ROOT/CMakeLists.txt" ]; then
+        _HIP_CMAKELIST_DIR="$CLR_ROOT"
+        _HIP_CMAKELIST_OPT="-DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF"
+        if [ -e "$HIPOTHER_ROOT/hipnv" ]; then
+            _HIP_CMAKELIST_OPT="$_HIP_CMAKELIST_OPT -DHIPNV_DIR=$HIPOTHER_ROOT/hipnv"
+        fi
+    elif [ ! -e "$HIPAMD_ROOT/CMakeLists.txt" ]; then
+        echo "No $HIPAMD_ROOT/CMakeLists.txt file, skipping hip on rocclr" >&2
+        echo "No $HIPAMD_ROOT/CMakeLists.txt file, skipping hip on rocclr"
+        exit 0
+    else
+        _HIP_CMAKELIST_DIR="$HIPAMD_ROOT"
+        _HIP_CMAKELIST_OPT=""
+    fi
+
+    echo "$_HIP_CMAKELIST_DIR"
+    mkdir -p "$BUILD_PATH"
+    pushd "$BUILD_PATH"
+
+    if [ ! -e Makefile ]; then
+        echo "Building HIP-On-ROCclr CMake environment"
+        print_lib_type $SHARED_LIBS
+
+        cmake $(rocm_cmake_params) \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            -DHIP_COMPILER=clang \
+            -DHIP_PLATFORM=amd \
+            -DHIP_COMMON_DIR="$HIP_ON_ROCclr_ROOT" \
+            $(rocm_common_cmake_params) \
+            -DCMAKE_HIP_ARCHITECTURES=OFF \
+            -DHSA_PATH="$ROCM_INSTALL_PATH" \
+            -DCMAKE_SKIP_BUILD_RPATH=TRUE \
+            -DCPACK_INSTALL_PREFIX="$ROCM_INSTALL_PATH" \
+            -DROCM_PATH="$ROCM_INSTALL_PATH" \
+            -DHIPCC_BIN_DIR="$HIPCC_BUILD_DIR" \
+            -DHIP_CATCH_TEST=1 \
+            $_HIP_CMAKELIST_OPT \
+            "$_HIP_CMAKELIST_DIR"
+
+        echo "CMake complete"
+    fi
+
+    echo "Build and Install HIP"
+    cmake --build . -- $MAKEOPTS install "VERBOSE=1"
+
+    popd
+}
+
+build_catch_tests() {
+   WORKSPACE=`pwd`
+   echo "Build catch2 tests independently"
+   if [ ! -e "$CATCH_SRC/CMakeLists.txt" ]; then
+      echo "catch source not found: $CATCH_SRC" >&2
+      exit
+   fi
+   # build catch
+   rm -rf "$CATCH_BUILD_DIR"
+   mkdir -p "$CATCH_BUILD_DIR"
+   pushd "$CATCH_BUILD_DIR"
+   export HIP_PATH="$ROCM_INSTALL_PATH"
+   export ROCM_PATH="$ROCM_INSTALL_PATH"
+   cmake \
+         -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+         -DHIP_PLATFORM=amd \
+         -DROCM_PATH="$ROCM_INSTALL_PATH" \
+         -DOFFLOAD_ARCH_STR="$OFFLOAD_ARCH_STR" \
+         $(rocm_common_cmake_params) \
+         -DCPACK_RPM_DEBUGINFO_PACKAGE=FALSE \
+         -DCPACK_DEBIAN_DEBUGINFO_PACKAGE=FALSE \
+         -DCPACK_INSTALL_PREFIX="$ROCM_INSTALL_PATH" \
+         "$CATCH_SRC"
+
+
+   make $MAKEOPTS build_tests
+   echo "Packaging catch tests"
+   make $MAKEOPTS package_test
+   copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" *.deb
+   copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" *.rpm
+   popd
+}
+
+package_samples() {
+   if [ "$ASAN_CMAKE_PARAMS" == "true" ] ; then
+      echo "Disable the packaging of HIP samples" >&2
+      return
+   fi
+   WORKSPACE=`pwd`
+   if [ ! -e "$SAMPLES_SRC/CMakeLists.txt" ]; then
+      echo "HIP samples source not found at: $SAMPLES_SRC" >&2
+      echo "Using samples package from hip project: $BUILD_PATH" >&2
+      return
+   fi
+
+   rm -rf "$SAMPLES_BUILD_DIR"
+   mkdir -p "$SAMPLES_BUILD_DIR"
+   pushd "$SAMPLES_BUILD_DIR"
+   local CMAKE_PATH="$(getCmakePath)"
+   export HIP_PATH="$ROCM_INSTALL_PATH"
+   export ROCM_PATH="$ROCM_INSTALL_PATH"
+   cmake \
+         -DROCM_PATH="$ROCM_INSTALL_PATH" \
+         $(rocm_common_cmake_params) \
+         -DCMAKE_MODULE_PATH="$CMAKE_PATH/hip" \
+         -DCPACK_INSTALL_PREFIX="$ROCM_INSTALL_PATH" \
+         "$SAMPLES_SRC"
+   echo "Packaging hip samples from hip-tests project"
+   make $MAKEOPTS package_samples
+   copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" *.deb
+   copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" *.rpm
+   popd
+}
+
+clean_hip_tests(){
+    rm -rf "$CATCH_BUILD_DIR"
+    rm -rf "$PACKAGE_SRC/hip-on-rocclr"
+    rm -rf "$PACKAGE_SRC/hipamd"
+    rm -rf "$PACKAGE_SRC/rocclr"
+    rm -rf "$PACKAGE_SRC/opencl-on-rocclr"
+    rm -rf "$PACKAGE_SRC/clr"
+    rm -rf "$PACKAGE_SRC/hip-tests"
+    rm -rf "$PACKAGE_SRC/hipother"
+}
+copy_hip_tests() {
+    clean_hip_tests
+
+    echo "Copy HIP & ROCclr Source and tests"
+
+    mkdir -p "$PACKAGE_SRC/hip-on-rocclr"
+    echo "Copying hip-on-rocclr"
+    progressCopy "$HIP_ON_ROCclr_ROOT" "$PACKAGE_SRC/hip-on-rocclr"
+
+    if [ -e "$CLR_ROOT/CMakeLists.txt" ]; then
+        mkdir -p "$PACKAGE_SRC/clr"
+        echo "Copying clr"
+        progressCopy "$CLR_ROOT" "$PACKAGE_SRC/clr"
+    else
+        mkdir -p "$PACKAGE_SRC/hipamd"
+        mkdir -p "$PACKAGE_SRC/rocclr"
+        mkdir -p "$PACKAGE_SRC/opencl-on-rocclr"
+        echo "Copying hipamd"
+        progressCopy "$HIPAMD_ROOT" "$PACKAGE_SRC/hipamd"
+        echo "Copying rocclr"
+        progressCopy "$ROCclr_ROOT" "$PACKAGE_SRC/rocclr"
+        echo "Copying opencl-on-rocclr"
+        progressCopy "$OPENCL_ON_ROCclr_ROOT" "$PACKAGE_SRC/opencl-on-rocclr"
+    fi
+
+    if [ -e "$HIPOTHER_ROOT/hipnv" ]; then
+        mkdir -p "$PACKAGE_SRC/hipother"
+        echo "Copying hipother"
+        progressCopy "$HIPOTHER_ROOT" "$PACKAGE_SRC/hipother"
+    fi
+
+    mkdir -p "$PACKAGE_SRC/hip-tests"
+    echo "Copying hip-tests"
+    progressCopy "$HIP_CATCH_TESTS_ROOT" "$PACKAGE_SRC/hip-tests"
+}
+
+package_hip_on_rocclr()
+{
+    echo "Packagin HIP-on-ROCclr"
+    pushd "$BUILD_PATH"
+    cmake --build . -- $MAKEOPTS package
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" *.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" *.rpm
+    popd
+}
+
+print_output_directory() {
+     case ${PKGTYPE} in
+         ("deb")
+             echo ${PACKAGE_DEB};;
+         ("rpm")
+             echo ${PACKAGE_RPM};;
+         (*)
+             echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+     esac
+     exit
+}
+
+case $TARGET in
+    (clean) clean_hip_on_rocclr; clean_hip_tests ;;
+    (build) build_hip_on_rocclr; build_catch_tests; package_hip_on_rocclr; package_samples; copy_hip_tests;;
+   (outdir) print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_hipblas.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipBLAS
+
+build_hipblas() {
+    echo "Start build"
+
+    CXX="g++"
+    CLIENTS_SAMPLES="ON"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+       CLIENTS_SAMPLES="OFF"
+    fi
+
+    echo "C compiler: $CC"
+    echo "CXX compiler: $CXX"
+    echo "FC compiler: $FC"
+
+    cd $COMPONENT_SRC
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       rebuild_lapack
+    fi
+
+    cmake \
+        ${LAUNCHER_FLAGS} \
+	$(rocm_common_cmake_params) \
+        -DUSE_CUDA=OFF \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DBUILD_CLIENTS_SAMPLES="${CLIENTS_SAMPLES}" \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipblas() {
+    echo "Cleaning hipBLAS build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipblas ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipblas ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipblaslt.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipBLASLt
+
+build_hipblaslt() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    cd $COMPONENT_SRC
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       rebuild_lapack
+    fi
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        # gfx90a:xnack+;gfx90a:xnack-;gfx940;gfx941;gfx942
+        GPU_TARGETS=all
+    fi
+
+    CXX=$(set_build_variables CXX)\
+    cmake \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        ${LAUNCHER_FLAGS} \
+         $(rocm_common_cmake_params) \
+        -DTensile_LOGIC= \
+        -DTensile_CODE_OBJECT_VERSION=default \
+        -DTensile_CPU_THREADS= \
+        -DTensile_LIBRARY_FORMAT=msgpack \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipblaslt() {
+    echo "Cleaning hipBLASLt build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipblaslt ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipblaslt ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipcc.sh

@@ -0,0 +1,118 @@
+#!/bin/bash
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -h,  --help               Prints this help"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+                            type referred to by pkg_type"
+    echo "  -r,  --release            Makes a release build"
+    echo
+
+    return 0
+}
+
+
+API_NAME=hipcc
+PROJ_NAME=$API_NAME
+
+TARGET="build"
+MAKEOPTS="$DASH_JAY"
+BUILD_TYPE="Debug"
+
+BUILD_DIR=$(getBuildPath $API_NAME)
+PACKAGE_DEB=$(getPackageRoot)/deb/$API_NAME
+PACKAGE_RPM=$(getPackageRoot)/rpm/$API_NAME
+PACKAGE_SRC="$(getSrcPath)"
+
+while [ "$1" != "" ];
+do
+    case $1 in
+        (-a  | --address_sanitizer)
+            ack_and_ignore_asan ;;
+        (-c  | --clean)
+            TARGET="clean" ;;
+        (-o | --outdir)
+            TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 1 ;;
+        (-r  | --release)
+            BUILD_TYPE="RelWithDebInfo" ;;
+        (-h  | --help)
+            printUsage ; exit 0 ;;
+        (*)
+            echo "Invalid option [$1]" >&2; printUsage; exit 1 ;;
+    esac
+    shift 1
+done
+
+clean() {
+    echo "Cleaning hipcc"
+    rm -rf $BUILD_DIR
+
+    echo "Cleaning up hipcc DEB and RPM packages"
+    rm -rf $PACKAGE_DEB
+    rm -rf $PACKAGE_RPM
+}
+
+copy_hipcc_sources() {
+    echo "Clean up hipcc build folder"
+    rm -rf "$PACKAGE_SRC/hipcc"
+    echo "Copy hipcc sources"
+    mkdir -p "$PACKAGE_SRC/hipcc"
+    progressCopy "$HIPCC_ROOT" "$PACKAGE_SRC/hipcc"
+}
+
+build() {
+    echo "Build hipcc binary"
+    mkdir -p "$BUILD_DIR"
+
+    pushd "$BUILD_DIR"
+    if ! [ -e "$HIPCC_ROOT/CMakeLists.txt" ] ; then
+
+        echo "No source for hipcc, exiting. this is not an error" >&2
+        exit 0
+    fi
+
+    cmake \
+        $(rocm_cmake_params) \
+        $(rocm_common_cmake_params) \
+        -DHIPCC_BACKWARD_COMPATIBILITY=OFF \
+        -DCMAKE_INSTALL_PREFIX="$OUT_DIR" \
+        $HIPCC_ROOT
+    popd
+
+    cmake --build "$BUILD_DIR" -- $MAKEOPTS
+    
+    echo "Installing and Packaging hipcc"
+    cmake --build "$BUILD_DIR" -- $MAKEOPTS install
+    cmake --build "$BUILD_DIR" -- $MAKEOPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" $BUILD_DIR/hipcc*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" $BUILD_DIR/hipcc*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1 ;;
+    esac
+    exit
+}
+
+case $TARGET in
+    (clean) clean ;;
+    (build) build ; copy_hipcc_sources ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_hipcub.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipCUB
+
+build_hipcub() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+         ASAN_CMAKE_PARAMS="false"
+    fi
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX=$(set_build_variables CXX)\
+    cmake \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip;${ROCM_PATH}/hip/cmake" \
+        -Drocprim_DIR="${ROCM_PATH}/rocprim"  \
+        -DBUILD_TEST=ON \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipcub() {
+    echo "Cleaning hipCUB build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipcub ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipcub ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipfft.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipFFT
+
+build_hipfft() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    cd $COMPONENT_SRC
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    cmake \
+        -DCMAKE_CXX_COMPILER=$(set_build_variables CXX) \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip" \
+        -DCMAKE_SKIP_BUILD_RPATH=TRUE \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -L \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR  && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipfft() {
+    echo "Cleaning hipFFT build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipfft ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipfft ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipfort.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipfort
+
+build_hipfort() {
+    echo "Start build"
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+    cmake --trace \
+        -DHIPFORT_INSTALL_DIR="${ROCM_PATH}" \
+        -DCMAKE_PREFIX_PATH="${ROCM_PATH}/llvm;${ROCM_PATH}" \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DHIPFORT_COMPILER="${ROCM_PATH}/${ROCM_LLVMDIR}/bin/flang" \
+        -DCMAKE_Fortran_FLAGS="-Mfree" \
+        -DHIPFORT_COMPILER_FLAGS="-cpp" \
+        -DCMAKE_Fortran_FLAGS_DEBUG="" \
+        ${LAUNCHER_FLAGS} \
+        -DROCM_SYMLINK_LIBS=OFF \
+	-DCMAKE_INSTALL_PREFIX=${ROCM_PATH} \
+        -DHIPFORT_AR="${ROCM_PATH}/${ROCM_LLVMDIR}/bin/llvm-ar" \
+        -DHIPFORT_RANLIB="${ROCM_PATH}/${ROCM_LLVMDIR}/bin/llvm-ranlib" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipfort() {
+    echo "Cleaning hipFORT build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipfort ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipfort ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipify_clang.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -h,  --help             Prints this help"
+    echo "  -r,  --release          Make a release build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo
+
+    return 0
+}
+
+TARGET="build"
+MAKEOPTS="$DASH_JAY"
+HIPIFY_CLANG_BUILD_DIR="$(getBuildPath $HIPIFY_ROOT)"
+HIPIFY_CLANG_DIST_DIR="$HIPIFY_CLANG_BUILD_DIR/dist"
+BUILD_TYPE="Debug"
+PACKAGE_ROOT="$(getPackageRoot)"
+HIPIFY_CLANG_HASH=""
+LIGHTNING_PATH="$ROCM_INSTALL_PATH/llvm"
+ADDRESS_SANITIZER=false
+DEB_PATH="$(getDebPath hipify)"
+RPM_PATH="$(getRpmPath hipify)"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso: --long help,clean,release,static,address_sanitizer,outdir: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on
+                ADDRESS_SANITIZER=true ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_hipify() {
+    echo "Cleaning hipify-clang"
+    rm -rf "$HIPIFY_CLANG_BUILD_DIR"
+    rm -rf "$HIPIFY_CLANG_DIST_DIR"
+    rm -rf "$DEB_PATH"
+    rm -rf "$RPM_PATH"
+}
+
+package_hipify() {
+    if [ "$PACKAGEEXT" = "deb" ]; then
+        rm -rf "$DEB_PATH"
+        mkdir -p "$DEB_PATH"
+    fi
+
+    if [ "$PACKAGEEXT" = "rpm" ]; then
+        rm -rf "$RPM_PATH"
+        mkdir -p "$RPM_PATH"
+    fi
+
+    pushd "$HIPIFY_CLANG_BUILD_DIR"
+    make $MAKEOPTS package_hipify-clang
+    popd
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$DEB_PATH"  $HIPIFY_CLANG_BUILD_DIR/hipify*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$RPM_PATH"  $HIPIFY_CLANG_BUILD_DIR/hipify*.rpm
+}
+
+build_hipify() {
+    echo "Building hipify-clang binaries"
+    mkdir -p "$HIPIFY_CLANG_BUILD_DIR"
+    mkdir -p "$HIPIFY_CLANG_DIST_DIR"
+
+    pushd "$HIPIFY_CLANG_BUILD_DIR"
+    cmake \
+        -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
+        $(rocm_common_cmake_params) \
+        -DCMAKE_INSTALL_PREFIX="$HIPIFY_CLANG_DIST_DIR" \
+        -DCPACK_PACKAGING_INSTALL_PREFIX=$ROCM_INSTALL_PATH \
+        -DCMAKE_PREFIX_PATH="$LIGHTNING_PATH" \
+        -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+        $HIPIFY_ROOT
+
+    cmake --build . -- $MAKEOPTS install
+    popd
+    pushd "$HIPIFY_ROOT"
+        HIPIFY_CLANG_HASH=`git describe --dirty --long --match [0-9]* --always`
+    popd
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${DEB_PATH};;
+        ("rpm")
+            echo ${RPM_PATH};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+case $TARGET in
+    (clean) clean_hipify ;;
+    (build) build_hipify; package_hipify ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_hiprand.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipRAND
+
+while [ "$1" != "" ];
+do
+    case $1 in
+        -o  | --outdir )
+            shift 1; PKGTYPE=$1 ; TARGET="outdir" ;;
+        -c  | --clean )
+            TARGET="clean" ;;
+        *)
+            break ;;
+    esac
+    shift 1
+done
+
+build_hiprand() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+    fi
+
+    cd $COMPONENT_SRC
+
+    remote_name=$(git remote show | head -n 1)
+    [ "$remote_name" == "origin" ] || git remote rename "$remote_name" origin
+    git submodule update --init --force
+
+    mkdir "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX=$(set_build_variables CXX)\
+    cmake \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DBUILD_TEST=ON \
+        -DBUILD_BENCHMARK=ON \
+        -DBUILD_CRUSH_TEST=ON \
+        -DDEPENDENCIES_FORCE_DOWNLOAD=ON \
+        -DHIP_COMPILER=clang \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip" \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/  && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    $SCCACHE_BIN -s || echo "Unable to display sccache stats"
+}
+
+clean_hiprand() {
+    echo "Cleaning hipRAND build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${DEB_PATH};;
+        ("rpm")
+            echo ${RPM_PATH};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+case $TARGET in
+    build) build_hiprand ;;
+    outdir) print_output_directory ;;
+    clean) clean_hiprand ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipsolver.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipSOLVER
+
+build_hipsolver() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    CXX="g++"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    echo "C compiler: $CC"
+    echo "CXX compiler: $CXX"
+    echo "FC compiler: $FC"
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       rebuild_lapack
+    fi
+
+    cmake \
+        -DUSE_CUDA=OFF \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipsolver() {
+    echo "Cleaning hipSOLVER build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipsolver ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipsolver ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipsparse.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+PATH=${ROCM_PATH}/bin:$PATH
+set_component_src hipSPARSE
+
+build_hipsparse() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    CXX="g++"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+        set_asan_env_vars
+        set_address_sanitizer_on
+    fi
+
+    echo "C compiler: $CC"
+    echo "CXX compiler: $CXX"
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    cmake \
+        -DCPACK_SET_DESTDIR=OFF \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DUSE_CUDA=OFF  \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DCMAKE_INSTALL_PREFIX=${ROCM_PATH} \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip;${ROCM_PATH}/hip/cmake"  \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_hipsparse() {
+    echo "Cleaning hipSPARSE build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hipsparse ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipsparse ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hipsparselt.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipSPARSELt
+
+while [ "$1" != "" ];
+do
+    case $1 in
+        -o  | --outdir )
+            shift 1; PKGTYPE=$1 ; TARGET="outdir" ;;
+        -c  | --clean )
+            TARGET="clean" ;;
+        *)
+            break ;;
+    esac
+    shift 1
+done
+
+build_hipsparselt() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    cd $COMPONENT_SRC
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        # gfx940;gfx941;gfx942
+        GPU_TARGETS=all
+    fi
+
+    FC=gfortran \
+    CXX="${ROCM_PATH}/bin/hipcc" \
+    cmake \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        ${LAUNCHER_FLAGS} \
+         $(rocm_common_cmake_params) \
+        -DTensile_LOGIC= \
+        -DTensile_CODE_OBJECT_VERSION=default \
+        -DTensile_CPU_THREADS= \
+        -DTensile_LIBRARY_FORMAT=msgpack \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DCMAKE_INSTALL_PREFIX=${ROCM_PATH} \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    $SCCACHE_BIN -s || echo "Unable to display sccache stats"
+}
+
+clean_hipsparselt() {
+    echo "Cleaning hipSPARSELt build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${DEB_PATH};;
+        ("rpm")
+            echo ${RPM_PATH};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+case $TARGET in
+    build) build_hipsparselt ;;
+    outdir) print_output_directory ;;
+    clean) clean_hipsparselt ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hiptensor.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src hipTensor
+
+build_hiptensor() {
+    echo "Start build hipTensor"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+        set_asan_env_vars
+        set_address_sanitizer_on
+    fi
+
+    cd "$COMPONENT_SRC"
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942"
+    fi
+
+    cmake \
+        -B "${BUILD_DIR}" \
+        $(rocm_common_cmake_params) \
+        $(set_build_variables CMAKE_C_CXX) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        ${LAUNCHER_FLAGS} \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p "$PACKAGE_DIR" && cp ${BUILD_DIR}/*.${PKGTYPE} "$PACKAGE_DIR"
+
+    show_build_cache_stats
+}
+
+clean_hiptensor() {
+    echo "Cleaning hipTensor build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_hiptensor ;;
+    outdir) print_output_directory ;;
+    clean) clean_hiptensor ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_hsa.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...] [make options]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo
+    echo
+
+    return 0
+}
+
+TARGET="build"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_SRC="$(getSrcPath)"
+PACKAGE_LIB="$(getLibPath)"
+PACKAGE_BIN="$(getBinPath)"
+PACKAGE_DEB="$(getPackageRoot)/deb/rocr"
+PACKAGE_RPM="$(getPackageRoot)/rpm/rocr"
+MAKEARG=""
+CORE_BUILD_DIR="$(getBuildPath hsa-core)"
+ROCR_DEV_BUILD_DIR="$(getBuildPath hsa-rocr-dev)"
+PREFIX_PATH="$PACKAGE_ROOT"
+BUILD_TYPE="Debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+unset HIP_DEVICE_LIB_PATH
+unset ROCM_PATH
+
+VALID_STR=`getopt -o hcraso: --long help,clean,release,static,address_sanitizer,outdir: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_hsa() {
+    echo "Cleaning HSA"
+
+    rm -rf "$CORE_BUILD_DIR"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "$PACKAGE_DEB"
+    rm -f  "$PACKAGE_ROOT"/lib/libhsa-runtime*
+    rm -rf "$PACKAGE_ROOT/lib/cmake/hsa-runtime64"
+    rm -rf "$PACKAGE_ROOT/include/hsa"
+    rm -rf "$PACKAGE_ROOT/share/doc/hsa-runtime64"
+    rm -rf "$PACKAGE_ROOT/hsa"
+}
+
+
+build_hsa_core() {
+    echo "Build HSA"
+    local coreMakeOpts="$DASH_JAY -C $CORE_BUILD_DIR"
+
+    echo "$HSA_CORE_ROOT"
+
+    if [ ! -d "$CORE_BUILD_DIR" ]; then
+        mkdir -p "$CORE_BUILD_DIR"
+        pushd "$CORE_BUILD_DIR"
+        print_lib_type $SHARED_LIBS
+
+        cmake $(rocm_cmake_params) \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            -DENABLE_LDCONFIG=OFF \
+            $(rocm_common_cmake_params) \
+            -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+            "$HSA_CORE_ROOT"
+        popd
+    fi
+    time cmake --build "$CORE_BUILD_DIR" -- $coreMakeOpts
+    time cmake --build "$CORE_BUILD_DIR" -- $coreMakeOpts install
+    time cmake --build "$CORE_BUILD_DIR" -- $coreMakeOpts package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" $CORE_BUILD_DIR/hsa-rocr*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" $CORE_BUILD_DIR/hsa-rocr*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+case $TARGET in
+    (clean) clean_hsa ;;
+    (build) build_hsa_core;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_miopen-deps.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src MIOpen
+
+build_miopen_mlir() {
+    echo "Building rocMLIR"
+    mlir_commit="$1"
+    if [ -z "$mlir_commit" ]; then
+        echo "rocMLIR entry was not found in requirements.txt"
+        return
+    fi
+    mkdir -p /var/tmp/rocMLIR && cd /var/tmp/rocMLIR
+    wget -nv "https://www.github.com/ROCmSoftwarePlatform/rocMLIR/archive/${mlir_commit}.tar.gz"
+    tar -xzf "${mlir_commit}.tar.gz"
+    cd "rocMLIR-${mlir_commit}"
+    mkdir build && cd build
+    cmake \
+        -G Ninja \
+        -DCMAKE_C_COMPILER="${ROCM_PATH}/llvm/bin/clang" \
+        -DCMAKE_CXX_COMPILER="${ROCM_PATH}/llvm/bin/clang++" \
+        -DCMAKE_BUILD_TYPE=Release \
+	-DCMAKE_PREFIX_PATH="${ROCM_PATH};${HOME}/miopen-deps" \
+        -DCMAKE_INSTALL_PREFIX="$ROCM_PATH" \
+        -DBUILD_FAT_LIBROCKCOMPILER=1 \
+       .. 
+    cmake --build . -- librockCompiler -j${PROC}
+    cmake --build . -- install
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    
+    echo "Finished building rocMLIR"
+}
+
+clean_miopen_mlir() {
+    echo "Cleaning rocMLIR"
+    rm -rf /var/tmp/rocMLIR
+}
+
+build_miopen_deps() {
+    echo "Start build"
+    cd "$COMPONENT_SRC"
+
+    # Commenting the rocMLIR & composable_kernel from requirements.txt
+    sed -i '/ROCmSoftwarePlatform\/rocMLIR@\|ROCmSoftwarePlatform\/composable_kernel@/s/^/#/' requirements.txt
+    # Extract MLIR commit from requirements.txt
+    MLIR_COMMIT="$(awk '/rocMLIR/ {split($1, s, "@"); print s[2]}' requirements.txt)"
+
+
+    pip3 install https://github.com/RadeonOpenCompute/rbuild/archive/master.tar.gz
+    PATH="${PATH}:${ROCM_PATH}:${HOME}/.local/bin" rbuild prepare -d "$HOME/miopen-deps" --cxx=${ROCM_PATH}/llvm/bin/clang++ --cc ${ROCM_PATH}/llvm/bin/clang
+    build_miopen_mlir "$MLIR_COMMIT"
+
+    show_build_cache_stats
+}
+
+clean_miopen_deps() {
+    echo "Cleaning MIOpen-Deps build directory: ${BUILD_DIR}"
+    rm -rf "$BUILD_DIR"
+    clean_miopen_mlir
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_miopen_deps ;;
+    outdir) ;;
+    clean) clean_miopen_deps ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_miopen-hip.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src MIOpen
+
+PACKAGE_DIR=${PACKAGE_DIR%\/*}/miopen-hip
+DEB_PATH=$PACKAGE_DIR
+RPM_PATH=$PACKAGE_DIR
+
+build_miopen_hip() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    checkout_lfs
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+   fi
+
+    mkdir "$BUILD_DIR" && cd "$BUILD_DIR"
+    cmake \
+        $(rocm_common_cmake_params) \
+        -DMIOPEN_BACKEND=HIP \
+        -DCMAKE_CXX_COMPILER="${ROCM_PATH}/llvm/bin/clang++" \
+        -DCMAKE_C_COMPILER="${ROCM_PATH}/llvm/bin/clang" \
+        -DCMAKE_PREFIX_PATH="${ROCM_PATH};${ROCM_PATH}/hip;${HOME}/miopen-deps" \
+        -DHIP_OC_COMPILER="${ROCM_PATH}/bin/clang-ocl" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf $BUILD_DIR/_CPack_Packages/ && find $BUILD_DIR -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_miopen_hip() {
+    echo "Cleaning MIOpen-HIP build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+checkout_lfs() {
+    git lfs install --local --force
+    git lfs pull --exclude=
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_miopen_hip ;;
+    outdir) print_output_directory ;;
+    clean) clean_miopen_hip ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_mivisionx.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src MIVisionX
+BUILD_DEV=ON
+
+build_mivisionx() {
+    echo "Start build"
+
+    mkdir -p $BUILD_DIR && cd $BUILD_DIR
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+       BUILD_DEV=OFF
+    fi
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100"
+    fi
+
+    cmake \
+        $(rocm_common_cmake_params) \
+        -DROCM_PATH="$ROCM_PATH" \
+        -DBUILD_DEV=$BUILD_DEV \
+        -DCMAKE_INSTALL_LIBDIR=$(getInstallLibDir) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DROCM_DEP_ROCMCORE=ON \
+        -DROCAL_PYTHON=OFF \
+        ${LAUNCHER_FLAGS} \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cpack -G ${PKGTYPE^^}
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR
+    cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_mivisionx() {
+    echo "Cleaning MIVisionX build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_mivisionx ;;
+    outdir) print_output_directory ;;
+    clean) clean_mivisionx ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_opencl_on_rocclr.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...] [make options]"
+    echo
+    echo "Options:"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of type referred to by pkg_type"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+MAKEOPTS="$DASH_JAY"
+
+BUILD_PATH="$(getBuildPath opencl-on-rocclr)"
+
+TARGET="build"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_DEB="$PACKAGE_ROOT/deb/opencl-on-rocclr"
+PACKAGE_RPM="$PACKAGE_ROOT/rpm/opencl-on-rocclr"
+CORE_BUILD_DIR="$(getBuildPath hsa-core)"
+ROCclr_BUILD_DIR="$(getBuildPath rocclr)"
+BUILD_TYPE="Debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso: --long help,clean,release,static,address_sanitizer,outdir: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_opencl_on_rocclr() {
+    rm -rf "$BUILD_PATH"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "$PACKAGE_ROOT/bin/clinfo"
+    rm -rf "$PACKAGE_ROOT/lib/libOpenCL.so*"
+    rm -rf "$PACKAGE_ROOT/lib/libamdocl64.so"
+    rm -rf "$PACKAGE_ROOT/lib/libcltrace.so"
+}
+
+build_opencl_on_rocclr() {
+    if [  -e "$CLR_ROOT/CMakeLists.txt" ]; then
+        _OCL_CMAKELIST_DIR="$CLR_ROOT"
+        _OCL_CMAKELIST_OPT="-DCLR_BUILD_HIP=OFF -DCLR_BUILD_OCL=ON"
+    elif [ ! -e "$OPENCL_ON_ROCclr_ROOT/CMakeLists.txt" ]; then
+        echo "No $OPENCL_ON_ROCclr_ROOT/CMakeLists.txt file, skipping opencl on rocclr" >&2
+        echo "No $OPENCL_ON_ROCclr_ROOT/CMakeLists.txt file, skipping opencl on rocclr"
+        exit 0
+    else
+         _OCL_CMAKELIST_DIR="$OPENCL_ON_ROCclr_ROOT"
+         _OCL_CMAKELIST_OPT=""
+    fi
+
+    echo "$_OCL_CMAKELIST_DIR"
+    mkdir -p "$BUILD_PATH"
+    pushd "$BUILD_PATH"
+
+    if [ ! -e Makefile ]; then
+        echo "Building OpenCL-On-ROCclr CMake environment"
+
+        cmake \
+            $(rocm_cmake_params) \
+            -DUSE_COMGR_LIBRARY=ON \
+            $(rocm_common_cmake_params) \
+            -DLINK_COMGR_STATIC="no" \
+            -DBUILD_TESTS=ON \
+            $_OCL_CMAKELIST_OPT \
+            "$_OCL_CMAKELIST_DIR"
+
+        echo "CMake complete"
+    fi
+
+    echo "Building OpenCL-On-ROCclr"
+    cmake --build . -- $MAKEOPTS
+
+    echo "Installing OpenCL-On-ROCclr"
+    cmake --build . -- $MAKEOPTS install
+
+    popd
+}
+
+package_opencl_on_rocclr() {
+    echo "Packaging OpenCL-On-ROCclr"
+    pushd "$BUILD_PATH"
+    cmake --build . -- package
+    mkdir -p $PACKAGE_DEB
+    mkdir -p $PACKAGE_RPM
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" *.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" *.rpm
+    popd
+}
+
+print_output_directory() {
+     case ${PKGTYPE} in
+         ("deb")
+             echo ${PACKAGE_DEB};;
+         ("rpm")
+             echo ${PACKAGE_RPM};;
+         (*)
+             echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+     esac
+     exit
+}
+
+case $TARGET in
+    (clean) clean_opencl_on_rocclr ;;
+    (build) build_opencl_on_rocclr ; package_opencl_on_rocclr ;;
+   (outdir) print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_openmp_extras.sh

@@ -0,0 +1,673 @@
+#!/bin/bash
+
+source ${BASH_SOURCE%/*}/compute_utils.sh
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+       type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+packageMajorVersion="17.60"
+packageMinorVersion="0"
+packageVersion="${packageMajorVersion}.${packageMinorVersion}.${ROCM_LIBPATCH_VERSION}"
+BUILD_PATH="$(getBuildPath openmp-extras)"
+DEB_PATH="$(getDebPath openmp-extras)"
+RPM_PATH="$(getRpmPath openmp-extras)"
+TARGET="build"
+MAKEOPTS="$DASH_JAY"
+
+export INSTALL_PREFIX=${ROCM_INSTALL_PATH}
+
+while [ "$1" != "" ];
+do
+    case $1 in
+        -c  | --clean )
+            TARGET="clean" ;;
+        -p  | --package )
+            TARGET="package" ;;
+        -r  | --release )
+            ;;
+        -a  | --address_sanitizer )
+            set_asan_env_vars
+            set_address_sanitizer_on
+            export ROCM_CMAKECONFIG_PATH="$INSTALL_PREFIX/lib/asan/cmake"
+            export VERBOSE=1
+            export LDSHARED="$INSTALL_PREFIX/lib/llvm/bin/clang -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fwrapv -O2"
+            export SANITIZER=1 ;;
+        -o  | --outdir )
+            shift 1; PKGTYPE=$1 ; TARGET="outdir" ;;
+        -h  | --help )
+            printUsage ; exit 0 ;;
+        *)
+            MAKEARG=$@ ; break ;;
+    esac
+    shift 1
+done
+
+
+clean_openmp_extras() {
+    rm -rf "$BUILD_PATH"
+    rm -rf "$INSTALL_PREFIX/openmp-extras"
+}
+
+toStdoutStderr(){
+    printf '%s\n' "$@" >&2
+    printf '%s\n' "$@"
+}
+
+clean_examples(){
+    rm -f "$1"/*.sh
+    rm -f "$1"/fortran/*.sh
+    rm -f "$1"/openmp/*.sh
+}
+
+build_openmp_extras() {
+     mkdir -p "$BUILD_PATH"
+     pushd "$BUILD_PATH"
+     echo "Building openmp-extras"
+     echo BUILD_PATH: $BUILD_PATH
+     echo "INSTALL_PREFIX:$INSTALL_PREFIX"
+     export AOMP_STANDALONE_BUILD=0
+     set +e
+     checkDevel=$(grep "ENABLE_DEVEL_PACKAGE=ON" $AOMP_REPOS/aomp/bin/build_openmp.sh)
+     set -e
+     if [ "$checkDevel" == "" ]; then
+       export AOMP=$INSTALL_PREFIX/lib/llvm
+     else
+       export DEVEL_PACKAGE="devel/"
+       export AOMP=$INSTALL_PREFIX/openmp-extras
+     fi
+     export BUILD_AOMP=$BUILD_PATH
+
+     if [ "$EPSDB" == "1" ]; then
+       export ROCM_DIR=$ROCM_INSTALL_PATH
+     else
+       export ROCM_DIR=$INSTALL_PREFIX
+     fi
+
+     if [ -d "$ROCM_DIR" ]; then
+       echo "--------------------------"
+       echo "ROCM_DIR:"
+       echo "----------"
+       ls $ROCM_DIR
+       echo "--------------------------"
+     fi
+     if [ -d "$ROCM_DIR"/include ]; then
+       echo "ROCM_DIR/include:"
+       echo "----------"
+       ls $ROCM_DIR/include
+       echo "--------------------------"
+     fi
+     if [ -d "$ROCM_DIR"/include/hsa ]; then
+       echo "ROCM_DIR/include/hsa:"
+       echo "----------"
+       ls $ROCM_DIR/include/hsa
+       echo "--------------------------"
+     fi
+
+     export AOMP_JENKINS_BUILD_LIST="extras openmp pgmath flang flang_runtime"
+     echo "BEGIN Build of openmp-extras"
+     "$AOMP_REPOS"/aomp/bin/build_aomp.sh $MAKEARG
+     popd
+}
+
+package_openmp_extras_deb() {
+        local packageName=$1
+        local packageDeb="$packageDir/deb"
+        local packageArch="amd64"
+        local packageMaintainer="Openmp Extras Support <openmp-extras.support@amd.com>"
+        local packageSummary="OpenMP Extras provides openmp and flang libraries."
+        local packageSummaryLong="openmp-extras $packageVersion is based on LLVM 15 and is used for offloading to Radeon GPUs."
+        local debDependencies="rocm-llvm, rocm-device-libs, rocm-core"
+        local debRecommends="gcc, g++"
+        local controlFile="$packageDeb/openmp-extras/DEBIAN/control"
+
+        if [ "$packageName" == "openmp-extras-runtime" ]; then
+          packageType="runtime"
+          debDependencies="rocm-core, hsa-rocr"
+        else
+          local debProvides="openmp-extras"
+          local debConflicts="openmp-extras"
+          local debReplaces="openmp-extras"
+          packageType="devel"
+          debDependencies="$debDependencies, openmp-extras-runtime, hsa-rocr-dev"
+        fi
+
+        if [ -f "$BUILD_PATH"/build/installed_files.txt ] && [ ! -d "$INSTALL_PREFIX"/openmp-extras/devel ]; then
+          if [ "$packageType" == "runtime" ]; then
+            rm -rf "$packageDir"
+            rm -rf "$DEB_PATH"
+            mkdir -p "$DEB_PATH"
+            mkdir -p $packageDeb/openmp-extras
+
+            mkdir -p $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras
+            cp -r $AOMP_REPOS/aomp/LICENSE $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras/LICENSE.apache2
+            cp -r $AOMP_REPOS/aomp-extras/LICENSE $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras/LICENSE.mit
+            cp -r $AOMP_REPOS/flang/LICENSE.txt $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras/LICENSE.flang
+	  else
+            rm -rf $packageDeb/openmp-extras/*
+            mkdir -p $packageDeb/openmp-extras$copyPath/bin
+            cp -r --parents "$installPath"/lib-debug/src $packageDeb/openmp-extras
+	  fi
+        else
+          if [ "$packageType" == "runtime" ]; then
+            rm -rf "$packageDir"
+            rm -rf "$DEB_PATH"
+            mkdir -p "$DEB_PATH"
+            mkdir -p $packageDeb/openmp-extras$installPath
+            mkdir -p $packageDeb/openmp-extras$installPath/lib/clang/$llvm_ver/include
+            mkdir -p $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras
+            cp -r $AOMP_REPOS/aomp/LICENSE $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras/LICENSE.apache2
+            cp -r $AOMP_REPOS/aomp-extras/LICENSE $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras/LICENSE.mit
+            cp -r $AOMP_REPOS/flang/LICENSE.txt $packageDeb/openmp-extras$copyPath/share/doc/openmp-extras/LICENSE.flang
+          else
+            rm -rf $packageDeb/openmp-extras$installPath/*
+            rm -rf $packageDeb/openmp-extras/bin
+            rm -rf $packageDeb/openmp-extras$copyPath/share
+            echo mkdir -p $packageDeb/openmp-extras$copyPath/bin
+            mkdir -p $packageDeb/openmp-extras$copyPath/bin
+            mkdir -p $packageDeb/openmp-extras$installPath/lib/clang/$llvm_ver/include
+          fi
+	fi
+
+        mkdir -p "$(dirname $controlFile)"
+
+	if [ -f "$BUILD_PATH"/build/installed_files.txt ] && [ ! -d "$INSTALL_PREFIX"/openmp-extras/devel ]; then
+	  if [ "$packageType" == "runtime" ]; then
+	    cat "$BUILD_PATH"/build/installed_files.txt | grep -P '\.so|\.a' | cut -d":" -f2 | cut -d" " -f2 | xargs -I {} cp -d --parents {} "$packageDeb"/openmp-extras
+
+	    cp -d --parents "$installPath/lib/libgomp.so" "$packageDeb"/openmp-extras
+	    cp -d --parents "$installPath/lib/libiomp5.so" "$packageDeb"/openmp-extras
+	    cp -d --parents "$installPath/lib-debug/libgomp.so" "$packageDeb"/openmp-extras
+	    cp -d --parents "$installPath/lib-debug/libiomp5.so" "$packageDeb"/openmp-extras
+	  else
+	    cat "$BUILD_PATH"/build/installed_files.txt | grep -Pv '\.so|\.a' | cut -d":" -f2 | cut -d" " -f2 | xargs -I {} cp -d --parents {} "$packageDeb"/openmp-extras
+	  fi
+	else
+          cp -r "$AOMP"/"$packageType"/* "$packageDeb"/openmp-extras"$installPath"
+	fi
+
+        if [ "$packageType" == "devel" ]; then
+          mkdir -p "$packageDeb"/openmp-extras"$copyPath"/share/openmp-extras/examples
+          echo cp -r "$AOMP_REPOS"/aomp/examples/fortran "$packageDeb"/openmp-extras"$copyPath"/share/openmp-extras/examples
+          cp -r "$AOMP_REPOS"/aomp/examples/fortran "$packageDeb"/openmp-extras"$copyPath"/share/openmp-extras/examples
+          cp -r "$AOMP_REPOS"/aomp/examples/openmp "$packageDeb"/openmp-extras"$copyPath"/share/openmp-extras/examples
+          cp -r "$AOMP_REPOS"/aomp/examples/tools "$packageDeb"/openmp-extras"$copyPath"/share/openmp-extras/examples
+          clean_examples "$packageDeb"/openmp-extras"$copyPath"/share/openmp-extras/examples
+        fi
+
+        if [ "$packageType" == "devel" ]; then
+          ln -s ../../../../include/omp.h $packageDeb/openmp-extras$installPath/lib/clang/$llvm_ver/include/omp.h
+          ln -s ../../../../include/ompt.h $packageDeb/openmp-extras$installPath/lib/clang/$llvm_ver/include/ompt.h
+          ln -s ../../../../include/omp-tools.h $packageDeb/openmp-extras$installPath/lib/clang/$llvm_ver/include/omp-tools.h
+          if [ ! -h "$packageDeb"/openmp-extras"$copyPath"/bin/aompcc ] && [ -e "$packageDeb"/openmp-extras"$installPath"/bin/aompcc ]; then
+            ln -s ../lib/llvm/bin/aompcc "$packageDeb"/openmp-extras"$copyPath"/bin/aompcc
+          fi
+          if [ -e "$packageDeb"/openmp-extras"$installPath"/bin/mymcpu ]; then
+            ln -s ../lib/llvm/bin/mymcpu "$packageDeb"/openmp-extras"$copyPath"/bin/mymcpu
+          fi
+          if [ -e "$packageDeb"/openmp-extras"$installPath"/bin/mygpu ]; then
+            ln -s ../lib/llvm/bin/mygpu "$packageDeb"/openmp-extras"$copyPath"/bin/mygpu
+          fi
+        fi
+
+        ls -l "$packageDeb"/openmp-extras"$installPath"
+	if [ "$packageType" == "devel" ]; then
+          ls -l "$packageDeb"/openmp-extras"$installPath"/bin
+          ls -l "$packageDeb"/openmp-extras"$copyPath"/bin
+	fi
+
+        {
+          echo "Package: $packageName"
+          echo "Architecture: $packageArch"
+          echo "Section: devel"
+          echo "Priority: optional"
+          echo "Maintainer: $packageMaintainer"
+          echo "Version: $packageVersion-${CPACK_DEBIAN_PACKAGE_RELEASE}"
+          echo "Depends: $debDependencies"
+          echo "Recommends: $debRecommends"
+          if [ "$packageType" == "devel" ]; then
+            echo "Provides: $debProvides"
+            echo "Conflicts: $debConflicts"
+            echo "Replaces: $debReplaces"
+          fi
+          echo "Description: $packageSummary"
+          echo "  $packageSummaryLong"
+        } > $controlFile
+        fakeroot dpkg-deb -Zgzip --build $packageDeb/openmp-extras \
+        "$DEB_PATH/${packageName}_${packageVersion}-${CPACK_DEBIAN_PACKAGE_RELEASE}_${packageArch}.deb"
+}
+
+package_openmp_extras_asan_deb() {
+        local packageName=$1
+        local packageDeb="$packageDir/deb"
+        local packageArch="amd64"
+        local packageMaintainer="Openmp Extras Support <openmp-extras.support@amd.com>"
+        local packageSummary="AddressSanitizer OpenMP Extras provides instrumented openmp and flang libraries."
+        local packageSummaryLong="openmp-extras $packageVersion is based on LLVM 15 and is used for offloading to Radeon GPUs."
+        local debDependencies="hsa-rocr-asan, rocm-core-asan"
+        local debRecommends="gcc, g++"
+        local controlFile="$packageDeb/openmp-extras/DEBIAN/control"
+        local asanLibDir="runtime"
+
+        rm -rf "$packageDir"
+        rm -rf "$DEB_PATH"
+        mkdir -p "$DEB_PATH"
+        local licenseDir="$packageDeb/openmp-extras$copyPath/share/doc/openmp-extras-asan"
+        mkdir -p $licenseDir
+        cp -r $AOMP_REPOS/aomp/LICENSE $licenseDir/LICENSE.apache2
+        cp -r $AOMP_REPOS/aomp-extras/LICENSE $licenseDir/LICENSE.mit
+        cp -r $AOMP_REPOS/flang/LICENSE.txt $licenseDir/LICENSE.flang
+
+        mkdir -p "$(dirname $controlFile)"
+        if [ -f "$BUILD_PATH"/build/installed_files.txt ] && [ ! -d "$INSTALL_PREFIX"/openmp-extras ]; then
+	  cat "$BUILD_PATH"/build/installed_files.txt | grep -P 'asan' | cut -d":" -f2 | cut -d" " -f2 | xargs -I {} cp -d --parents {} "$packageDeb"/openmp-extras
+
+	  cp -d --parents "$installPath/lib/asan/libgomp.so" "$packageDeb"/openmp-extras
+	  cp -d --parents "$installPath/lib/asan/libiomp5.so" "$packageDeb"/openmp-extras
+	  cp -d --parents "$installPath/lib-debug/asan/libgomp.so" "$packageDeb"/openmp-extras
+	  cp -d --parents "$installPath/lib-debug/asan/libiomp5.so" "$packageDeb"/openmp-extras
+
+        else
+          mkdir -p $packageDeb/openmp-extras$installPath/lib/asan
+          mkdir -p $packageDeb/openmp-extras$installPath/lib-debug/asan
+          cp -r "$AOMP"/lib/asan/* "$packageDeb"/openmp-extras"$installPath"/lib/asan/
+          cp -r "$AOMP"/lib-debug/asan/* "$packageDeb"/openmp-extras"$installPath"/lib-debug/asan/
+          cp -r "$AOMP"/"$asanLibDir"/lib/asan/* "$packageDeb"/openmp-extras"$installPath"/lib/asan/
+          cp -r "$AOMP"/"$asanLibDir"/lib-debug/asan/* "$packageDeb"/openmp-extras"$installPath"/lib-debug/asan/
+          cp -r "$AOMP"/devel/lib/asan/* "$packageDeb"/openmp-extras"$installPath"/lib/asan/
+          cp -r "$AOMP"/devel/lib-debug/asan/* "$packageDeb"/openmp-extras"$installPath"/lib-debug/asan/
+        fi
+
+        {
+          echo "Package: $packageName"
+          echo "Architecture: $packageArch"
+          echo "Section: devel"
+          echo "Priority: optional"
+          echo "Maintainer: $packageMaintainer"
+          echo "Version: $packageVersion-${CPACK_DEBIAN_PACKAGE_RELEASE}"
+          echo "Depends: $debDependencies"
+          echo "Recommends: $debRecommends"
+          echo "Description: $packageSummary"
+          echo "  $packageSummaryLong"
+        } > $controlFile
+        fakeroot dpkg-deb -Zgzip --build $packageDeb/openmp-extras \
+        "$DEB_PATH/${packageName}_${packageVersion}-${CPACK_DEBIAN_PACKAGE_RELEASE}_${packageArch}.deb"
+}
+
+
+package_openmp_extras_rpm() {
+        local packageName=$1
+        local packageRpm="$packageDir/rpm"
+        local specFile="$packageDir/$packageName.spec"
+        local packageSummary="OpenMP Extras provides openmp and flang libraries."
+        local packageSummaryLong="openmp-extras $packageVersion is based on LLVM 15 and is used for offloading to Radeon GPUs."
+        local rpmRequires="rocm-llvm, rocm-device-libs, rocm-core"
+        if [ "$packageName" == "openmp-extras-runtime" ]; then
+          packageType="runtime"
+          rpmRequires="rocm-core, hsa-rocr"
+        else
+          local rpmProvides="openmp-extras"
+          local rpmObsoletes="openmp-extras"
+          packageType="devel"
+          rpmRequires="$rpmRequires, openmp-extras-runtime, hsa-rocr-devel"
+        fi
+
+        rm -f "$AOMP_REPOS"/aomp/examples/*.sh
+        rm -f "$AOMP_REPOS"/aomp/examples/fortran/*.sh
+        rm -f "$AOMP_REPOS"/aomp/examples/openmp/*.sh
+
+
+        if [ "$packageType" == "runtime" ]; then
+          rm -rf "$packageDir"
+          rm -rf "$RPM_PATH"
+          mkdir -p "$RPM_PATH"
+        fi
+        echo RPM_PATH: $RPM_PATH
+        echo mkdir -p $(dirname $specFile)
+        mkdir -p "$(dirname $specFile)"
+
+        {
+          echo "%define is_runtime %( if [ $packageType == runtime ]; then echo "1" ; else echo "0"; fi )"
+          echo "%define is_devel %( if [ $packageType == devel ]; then echo "1" ; else echo "0"; fi )"
+
+          echo "Name:       $packageName"
+          echo "Version:    $packageVersion"
+          echo "Release:    ${CPACK_RPM_PACKAGE_RELEASE}%{?dist}"
+          echo "Summary:    $packageSummary"
+          echo "Group:      System Environment/Libraries"
+          echo "License:    MIT and ASL 2.0 and ASL 2.0 with exceptions"
+          echo "Vendor:     Advanced Micro Devices, Inc."
+          echo "Requires:   $rpmRequires"
+          echo "%if %is_devel"
+          echo "Provides:   $rpmProvides"
+          echo "Obsoletes:  $rpmObsoletes"
+          echo "%endif"
+          echo "%define debug_package %{nil}"
+          echo "%define __os_install_post %{nil}"
+          echo "%description"
+          echo "$packageSummaryLong"
+
+          echo "%prep"
+          echo "%setup -T -D -c -n $packageName"
+          echo "%build"
+
+          echo "%install"
+          echo "if [ -f $BUILD_PATH/build/installed_files.txt ] && [ ! -d $INSTALL_PREFIX/openmp-extras/devel ]; then"
+          echo "  %if %is_runtime"
+          echo "    mkdir -p \$RPM_BUILD_ROOT/openmp-extras"
+          echo "  %else"
+          echo "    mkdir -p \$RPM_BUILD_ROOT$copyPath/bin"
+          echo "    mkdir -p \$RPM_BUILD_ROOT$installPath/lib/clang/$llvm_ver/include"
+          echo "  %endif"
+          echo "else"
+          echo "  %if %is_runtime"
+          echo "    mkdir -p  \$RPM_BUILD_ROOT$installPath"
+          echo "  %else"
+          echo "    rm -rf \$RPM_BUILD_ROOT/openmp-extras$installPath/*"
+          echo "    echo mkdir -p \$RPM_BUILD_ROOT$copyPath/bin"
+          echo "    mkdir -p \$RPM_BUILD_ROOT$copyPath/bin"
+          echo "    mkdir -p \$RPM_BUILD_ROOT$installPath/lib/clang/$llvm_ver/include"
+          echo "  %endif"
+          echo "fi"
+
+          echo "if [ -f $BUILD_PATH/build/installed_files.txt ] && [ ! -d $INSTALL_PREFIX/openmp-extras/devel ]; then"
+          echo "  %if %is_runtime"
+          echo "    cat $BUILD_PATH/build/installed_files.txt | grep -P '\.so|\.a' | cut -d':' -f2 | cut -d' ' -f2 | xargs -I {} cp -d --parents {} \$RPM_BUILD_ROOT"
+
+          echo "    cp -d --parents "$installPath/lib/libgomp.so" \$RPM_BUILD_ROOT"
+          echo "    cp -d --parents "$installPath/lib/libiomp5.so" \$RPM_BUILD_ROOT"
+          echo "    cp -d --parents "$installPath/lib-debug/libgomp.so" \$RPM_BUILD_ROOT"
+          echo "    cp -d --parents "$installPath/lib-debug/libiomp5.so" \$RPM_BUILD_ROOT"
+          echo "  %endif"
+          echo "%if %is_devel"
+          echo "  cat "$BUILD_PATH"/build/installed_files.txt | grep -Pv '\.so|\.a' | cut -d':' -f2 | cut -d' ' -f2 | xargs -I {} cp -d --parents {} \$RPM_BUILD_ROOT"
+          echo "%endif"
+
+          echo "else"
+          echo "  cp -r $AOMP/$packageType/* \$RPM_BUILD_ROOT$installPath"
+          echo "  %if %is_devel"
+          echo "    rm -rf \$RPM_BUILD_ROOT$installPath/share"
+          echo "  %endif"
+          echo "fi"
+
+          echo "%if %is_devel"
+          echo "  if [ ! -h \$RPM_BUILD_ROOT$copyPath/bin/aompcc ] && [ -e \$RPM_BUILD_ROOT$installPath/bin/aompcc ]; then"
+          echo "    ln -s ../lib/llvm/bin/aompcc \$RPM_BUILD_ROOT$copyPath/bin/aompcc"
+          echo "  fi"
+          echo "  if [ -e \$RPM_BUILD_ROOT$installPath/bin/mymcpu ]; then"
+          echo "    ln -s ../lib/llvm/bin/mymcpu \$RPM_BUILD_ROOT$copyPath/bin/mymcpu"
+          echo "  fi"
+          echo "  if [ -e \$RPM_BUILD_ROOT$installPath/bin/mygpu ]; then"
+          echo "    ln -s ../lib/llvm/bin/mygpu \$RPM_BUILD_ROOT$copyPath/bin/mygpu"
+          echo "  fi"
+          echo "  ls \$RPM_BUILD_ROOT$copyPath"
+
+          echo "  ln -s ../../../../include/omp.h  \$RPM_BUILD_ROOT/$installPath/lib/clang/$llvm_ver/include/omp.h"
+          echo "  ln -s ../../../../include/ompt.h  \$RPM_BUILD_ROOT/$installPath/lib/clang/$llvm_ver/include/ompt.h"
+          echo "  ln -s ../../../../include/omp-tools.h \$RPM_BUILD_ROOT/$installPath/lib/clang/$llvm_ver/include/omp-tools.h"
+          echo "%endif"
+          echo 'find $RPM_BUILD_ROOT \! -type d | sed "s|$RPM_BUILD_ROOT||"> files.list'
+
+          echo "%if %is_runtime"
+          echo "  mkdir -p \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras"
+          echo "  cp -r $AOMP_REPOS/aomp/LICENSE \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras/LICENSE.apache2"
+          echo "  cp -r $AOMP_REPOS/aomp-extras/LICENSE \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras/LICENSE.mit"
+          echo "  cp -r $AOMP_REPOS/flang/LICENSE.txt \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras/LICENSE.flang"
+          echo "%else"
+          echo "  mkdir -p \$RPM_BUILD_ROOT$copyPath/share/openmp-extras/examples"
+          echo "  cp -r $AOMP_REPOS/aomp/examples/fortran \$RPM_BUILD_ROOT$copyPath/share/openmp-extras/examples"
+          echo "  cp -r $AOMP_REPOS/aomp/examples/openmp \$RPM_BUILD_ROOT$copyPath/share/openmp-extras/examples"
+          echo "  cp -r $AOMP_REPOS/aomp/examples/tools \$RPM_BUILD_ROOT$copyPath/share/openmp-extras/examples"
+          clean_examples \$RPM_BUILD_ROOT$copyPath/share/openmp-extras/examples
+          echo "%endif"
+          echo "%clean"
+          echo "rm -rf \$RPM_BUILD_ROOT"
+
+          echo "%files -f files.list"
+          echo "%if %is_runtime"
+          echo "  $copyPath/share/doc/openmp-extras"
+          echo "%else"
+          echo "  $copyPath/share/openmp-extras"
+          echo "%endif"
+          echo "%defattr(-,root,root,-)"
+          echo "%if %is_runtime || %is_devel"
+          echo "  $copyPath"
+          echo "%endif"
+
+        } > $specFile
+        rpmbuild --define "_topdir $packageRpm" -ba $specFile
+        mv $packageRpm/RPMS/x86_64/*.rpm $RPM_PATH
+}
+
+package_openmp_extras_asan_rpm() {
+        local packageName=$1
+        local packageRpm="$packageDir/rpm"
+        local specFile="$packageDir/$packageName.spec"
+        local packageSummary="AddressSanitizer OpenMP Extras provides instrumented openmp and flang libraries."
+        local packageSummaryLong="openmp-extras $packageVersion is based on LLVM 15 and is used for offloading to Radeon GPUs."
+        local rpmRequires="hsa-rocr-asan, rocm-core-asan"
+        local asanLibDir="runtime"
+
+        rm -rf "$packageDir"
+        rm -rf "$RPM_PATH"
+        mkdir -p "$RPM_PATH"
+        echo RPM_PATH: $RPM_PATH
+        echo mkdir -p $(dirname $specFile)
+        mkdir -p "$(dirname $specFile)"
+
+        {
+          echo "Name:       $packageName"
+          echo "Version:    $packageVersion"
+          echo "Release:    ${CPACK_RPM_PACKAGE_RELEASE}%{?dist}"
+          echo "Summary:    $packageSummary"
+          echo "Group:      System Environment/Libraries"
+          echo "License:    MIT and ASL 2.0 and ASL 2.0 with exceptions"
+          echo "Vendor:     Advanced Micro Devices, Inc."
+          echo "Requires:   $rpmRequires"
+          echo "%define __os_install_post %{nil}"
+          echo "%description"
+          echo "%undefine _debugsource_packages"
+          echo "$packageSummaryLong"
+
+          echo "%prep"
+          echo "%setup -T -D -c -n $packageName"
+          echo "%build"
+
+          echo "%install"
+          echo "if [ -f $BUILD_PATH/build/installed_files.txt ] && [ ! -d "$INSTALL_PREFIX"/openmp-extras ]; then"
+          echo "  cat $BUILD_PATH/build/installed_files.txt | grep -P 'asan' | cut -d':' -f2 | cut -d' ' -f2 | xargs -I {} cp -d --parents {} \$RPM_BUILD_ROOT"
+          echo "  cp -d --parents "$installPath/lib/asan/libgomp.so" \$RPM_BUILD_ROOT"
+          echo "  cp -d --parents "$installPath/lib/asan/libiomp5.so" \$RPM_BUILD_ROOT"
+          echo "  cp -d --parents "$installPath/lib-debug/asan/libgomp.so" \$RPM_BUILD_ROOT"
+          echo "  cp -d --parents "$installPath/lib-debug/asan/libiomp5.so" \$RPM_BUILD_ROOT"
+          echo "else"
+          echo "  mkdir -p  \$RPM_BUILD_ROOT$installPath/lib/asan"
+          echo "  mkdir -p  \$RPM_BUILD_ROOT$installPath/lib-debug/asan"
+          echo "  cp -r $AOMP/lib/asan/* \$RPM_BUILD_ROOT$installPath/lib/asan"
+          echo "  cp -r $AOMP/lib-debug/asan/* \$RPM_BUILD_ROOT$installPath/lib-debug/asan"
+          echo "  cp -r $AOMP/$asanLibDir/lib/asan/* \$RPM_BUILD_ROOT$installPath/lib/asan"
+          echo "  cp -r $AOMP/$asanLibDir/lib-debug/asan/* \$RPM_BUILD_ROOT$installPath/lib-debug/asan"
+          echo "  cp -r $AOMP/devel/lib/asan/* \$RPM_BUILD_ROOT$installPath/lib/asan"
+          echo "  cp -r $AOMP/devel/lib-debug/asan/* \$RPM_BUILD_ROOT$installPath/lib-debug/asan"
+          echo "fi"
+
+          echo 'find $RPM_BUILD_ROOT \! -type d | sed "s|$RPM_BUILD_ROOT||"> files.list'
+
+          echo "  mkdir -p \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras-asan"
+          echo "  cp -r $AOMP_REPOS/aomp/LICENSE \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras-asan/LICENSE.apache2"
+          echo "  cp -r $AOMP_REPOS/aomp-extras/LICENSE \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras-asan/LICENSE.mit"
+          echo "  cp -r $AOMP_REPOS/flang/LICENSE.txt \$RPM_BUILD_ROOT$copyPath/share/doc/openmp-extras-asan/LICENSE.flang"
+          echo "%clean"
+          echo "rm -rf \$RPM_BUILD_ROOT"
+
+          echo "%files -f files.list"
+          echo "  $copyPath/share/doc/openmp-extras-asan"
+          echo "%defattr(-,root,root,-)"
+          echo "  $copyPath"
+
+        } > $specFile
+        rpmbuild --define "_topdir $packageRpm" -ba $specFile
+        mv $packageRpm/RPMS/x86_64/*.rpm $RPM_PATH
+}
+
+
+package_openmp_extras() {
+    local DISTRO_NAME=$(cat /etc/os-release | grep -e ^NAME=)
+    local installPath="$ROCM_INSTALL_PATH/lib/llvm"
+    local copyPath="$ROCM_INSTALL_PATH"
+    local packageDir="$BUILD_PATH/package"
+    local llvm_ver=`$INSTALL_PREFIX/lib/llvm/bin/clang --print-resource-dir | sed 's^/llvm/lib/clang/^ ^' | awk '{print $2}'`
+    local debNames="openmp-extras-runtime openmp-extras-dev"
+    local rpmNames="openmp-extras-runtime openmp-extras-devel"
+    if [ "$SANITIZER" == "1" ]; then
+      local asanPkgName="openmp-extras-asan"
+      if [[ $DISTRO_NAME =~ "Ubuntu" ]]; then
+        package_openmp_extras_asan_deb $asanPkgName
+      else
+        package_openmp_extras_asan_rpm $asanPkgName
+      fi
+      return 0
+    fi
+
+    if [[ $DISTRO_NAME =~ "Ubuntu" ]]; then
+      for name in $debNames; do
+        package_openmp_extras_deb $name
+      done
+    else
+      for name in $rpmNames; do
+        package_openmp_extras_rpm $name
+      done
+    fi
+}
+
+package_tests_deb(){
+    local packageDir="$BUILD_PATH/package"
+    local packageDeb="$packageDir/deb"
+    local packageArch="amd64"
+    local packageMaintainer="Openmp Extras Support <openmp-extras.support@amd.com>"
+    local packageSummary="Tests for openmp-extras."
+    local packageSummaryLong="Tests for openmp-extras $packageMajorVersion-$packageMinorVersion is based on LLVM 15 and is used for offloading to Radeon GPUs."
+    local debDependencies="rocm-core"
+    local debRecommends="gcc, g++"
+    local controlFile="$packageDeb/openmp-extras/DEBIAN/control"
+    local installPath="$ROCM_INSTALL_PATH/share/openmp-extras/tests"
+    local packageName="openmp-extras-tests"
+
+    rm -rf "$packageDir"
+
+    mkdir -p $packageDeb/openmp-extras$installPath; mkdir -p $packageDeb/openmp-extras$copyPath/bin
+    if [ -e $(dirname $controlFile) ]; then
+        rm $(dirname $controlFile)
+    fi
+    mkdir -p "$(dirname $controlFile)"
+    cp -r "$AOMP_REPOS/aomp/test/smoke" "$packageDeb$installPath"
+    {
+      echo "Package: $packageName"
+      echo "Architecture: $packageArch"
+      echo "Section: devel"
+      echo "Priority: optional"
+      echo "Maintainer: $packageMaintainer"
+      echo "Version: $packageVersion-${CPACK_DEBIAN_PACKAGE_RELEASE}"
+      echo "Depends: $debDependencies"
+      echo "Recommends: $debRecommends"
+      echo "Description: $packageSummary"
+      echo "  $packageSummaryLong"
+    } > $controlFile
+    fakeroot dpkg-deb -Zgzip --build $packageDeb/openmp-extras \
+    "${DEB_PATH}/${packageName}_${packageVersion}-${CPACK_DEBIAN_PACKAGE_RELEASE}_${packageArch}.deb"
+}
+
+package_tests_rpm(){
+    AOMP_STANDALONE_BUILD=1 $AOMP_REPOS/aomp/bin/build_fixups.sh
+    local copyPath="$ROCM_INSTALL_PATH"
+    local packageDir="$BUILD_PATH/package"
+    local packageRpm="$packageDir/rpm"
+    local installPath="$ROCM_INSTALL_PATH/share/openmp-extras/tests"
+    local packageName="openmp-extras-tests"
+    local specFile="$packageDir/$packageName.spec"
+    local packageSummary="Tests for openmp-extras."
+    local packageSummaryLong="Tests for openmp-extras $packageVersion is based on LLVM 15 and is used for offloading to Radeon GPUs."
+
+    rm -rf "$packageDir"
+    mkdir -p "$packageRpm$installPath"
+    {
+      echo "Name:       $packageName"
+      echo "Version:    $packageVersion"
+      echo "Release:    ${CPACK_RPM_PACKAGE_RELEASE}%{?dist}"
+      echo "Summary:    $packageSummary"
+      echo "Group:      System Environment/Libraries"
+      echo "License:    Advanced Micro Devices, Inc."
+      echo "Vendor:     Advanced Micro Devices, Inc."
+      echo "%define debug_package %{nil}"
+      echo "%define __os_install_post %{nil}"
+      echo "%description"
+      echo "$packageSummaryLong"
+
+      echo "%prep"
+      echo "%setup -T -D -c -n $packageName"
+      echo "%build"
+
+      echo "%install"
+      echo "mkdir -p  \$RPM_BUILD_ROOT$copyPath/share/aomp/tests"
+      echo "cp -R $AOMP_REPOS/aomp/test/smoke \$RPM_BUILD_ROOT$copyPath/share/aomp/tests"
+      echo 'find $RPM_BUILD_ROOT \! -type d | sed "s|$RPM_BUILD_ROOT||"> files.list'
+
+      echo "%clean"
+      echo "rm -rf \$RPM_BUILD_ROOT"
+
+      echo "%files -f files.list"
+      echo "%defattr(-,root,root,-)"
+
+      echo "%postun"
+      echo "rm -rf $ROCM_INSTALL_PATH/share/aomp"
+    } > $specFile
+    rpmbuild --define "_topdir $packageRpm" -ba $specFile
+    mv $packageRpm/RPMS/x86_64/*.rpm $RPM_PATH
+}
+
+package_tests() {
+    local DISTRO_NAME=$(cat /etc/os-release | grep -e ^NAME=)
+    if [[ $DISTRO_NAME =~ "Ubuntu" ]]; then
+        package_tests_deb
+    else
+        package_tests_rpm
+    fi
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${DEB_PATH};;
+        ("rpm")
+            echo ${RPM_PATH};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+case $TARGET in
+    (clean) clean_openmp_extras ;;
+    (build) build_openmp_extras; package_openmp_extras ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rccl.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rccl
+
+ENABLE_ADDRESS_SANITIZER=false
+
+build_rccl() {
+    echo "Start build"
+
+    mkdir -p $ROCM_PATH/.info/
+    echo $ROCM_VERSION | tee $ROCM_PATH/.info/version
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    mkdir -p $BUILD_DIR && cd $BUILD_DIR
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+
+    CC=${ROCM_PATH}/bin/amdclang \
+    CXX=$(set_build_variables CXX) \
+    cmake \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DHIP_COMPILER=clang \
+        -DCMAKE_PREFIX_PATH="${ROCM_PATH};${ROCM_PATH}/share/rocm/cmake/" \
+        -DCPACK_GENERATOR="${PKGTYPE^^}" \
+        -DROCM_PATCH_VERSION=$ROCM_LIBPATCH_VERSION \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        -DBUILD_TESTS=ON \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rccl() {
+    echo "Cleaning rccl build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rccl ;;
+    outdir) print_output_directory ;;
+    clean) clean_rccl ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rdc.sh

@@ -0,0 +1,234 @@
+#!/bin/bash
+
+source "$(dirname "$BASH_SOURCE")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename $0) [-c|-r|-h] [makeopts]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean            Removes all rdc build artifacts, except grpc"
+    echo "  -g,  --clean_grpc       Removes the grpc files and artifacts"
+    echo "  -r,  --release          Build release version of RDC (default is debug)"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+        type referred to by pkg_type"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -h,  --help             Prints this help"
+    echo
+    return 0
+}
+
+PACKAGE_ROOT="$(getPackageRoot)"
+RDC_BUILD_DIR=$(getBuildPath rdc)
+GRPC_BUILD_DIR=$(getBuildPath grpc)
+TARGET="build"
+PACKAGE_LIB=$(getLibPath)
+PACKAGE_INCLUDE="$(getIncludePath)"
+PACKAGE_BIN="$(getBinPath)"
+RDC_PACKAGE_DEB_DIR="$PACKAGE_ROOT/deb/rdc"
+RDC_PACKAGE_RPM_DIR="$PACKAGE_ROOT/rpm/rdc"
+BUILD_TYPE="Debug"
+MAKETARGET="deb"
+MAKEARG="$DASH_JAY O=$RDC_BUILD_DIR"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+CLEAN_GRPC="no"
+PKGTYPE="deb"
+RDC_MAKE_OPTS="$DASH_JAY O=$RDC_BUILD_DIR -C $RDC_BUILD_DIR"
+BUILD_DOCS="no"
+RDC_PKG_NAME_ROOT="rdc"
+RDC_PKG_NAME="${RDC_PKG_NAME_ROOT}"
+GRPC_PROTOC_ROOT="${RDC_BUILD_DIR}/grpc"
+GRPC_SEARCH_ROOT="/usr/grpc"
+GRPC_DESIRED_VERSION="1.59.1" # do not include 'v'
+
+RDC_LIB_RPATH='$ORIGIN'
+RDC_LIB_RPATH=$RDC_LIB_RPATH:'$ORIGIN/..'
+RDC_LIB_RPATH=$RDC_LIB_RPATH:'$ORIGIN/rdc/grpc/lib'
+RDC_LIB_RPATH=$RDC_LIB_RPATH:'$ORIGIN/grpc/lib'
+RDC_EXE_RPATH='$ORIGIN/../lib'
+RDC_EXE_RPATH=$RDC_EXE_RPATH:'$ORIGIN/../lib/rdc/grpc/lib'
+
+VALID_STR=`getopt -o hcgradso:p: --long help,clean,clean_grpc,release,documentation,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-g | --clean_grpc)
+                TARGET="clean_grpc" ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-d | --documentation )
+                BUILD_DOCS="yes" ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_rdc() {
+    rm -rf "$RDC_BUILD_DIR"
+    rm -rf "$RDC_PACKAGE_DEB_DIR"
+    rm -rf "$RDC_PACKAGE_RPM_DIR"
+    rm -rf "$RDC_BUILD_DIR/rdc"
+
+    rm -rf "$PACKAGE_INCLUDE/rdc"
+    rm -f $PACKAGE_LIB/librdc*
+    rm -f $PACKAGE_BIN/rdci
+    return 0
+}
+
+clean_grpc() {
+    rm -rf "$GRPC_BUILD_DIR"
+}
+
+find_grpc() {
+    grep -s -F "$GRPC_DESIRED_VERSION" ${GRPC_SEARCH_ROOT}/*/cmake/grpc/gRPCConfigVersion.cmake &&
+        GRPC_PROTOC_ROOT=$GRPC_SEARCH_ROOT
+}
+
+build_grpc() {
+    if find_grpc; then
+        return 0
+    fi
+    echo "GRPC SEARCH FAILED! Building from scratch..."
+
+    mkdir -p $PACKAGE_ROOT/build
+    pushd $PACKAGE_ROOT/build
+
+    if [ ! -d $PACKAGE_ROOT/build/grpc/.git ]; then
+        git clone \
+            --shallow-submodules \
+            --recurse-submodules \
+            $DASH_JAY \
+            -b v${GRPC_DESIRED_VERSION} \
+            --depth 1 \
+            https://github.com/grpc/grpc
+    fi
+
+    cd grpc
+    mkdir -p cmake/build
+    cd cmake/build
+
+    cmake \
+        -DgRPC_INSTALL=ON \
+        -DgRPC_BUILD_TESTS=OFF \
+        -DBUILD_SHARED_LIBS=ON \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX=${GRPC_PROTOC_ROOT} \
+        ../..
+    cmake --build . -- $DASH_JAY
+    cmake --build . -- install
+
+    cp ../../LICENSE ${GRPC_PROTOC_ROOT}
+    popd
+}
+
+rdc_backwards_compat_cmake_params() {
+    grep -q "RDC_CLIENT_INSTALL_PREFIX" "$RDC_ROOT/CMakeLists.txt" &&
+        echo "-DRDC_CLIENT_INSTALL_PREFIX=$PACKAGE_ROOT"
+}
+
+build_rdc() {
+    echo "Building RDC"
+    echo "RDC_BUILD_DIR: ${RDC_BUILD_DIR}"
+    echo "GRPC_PROTOC_ROOT: ${GRPC_PROTOC_ROOT}"
+
+    export LD_PRELOAD="$ASAN_LIB_PATH"
+
+    if [ ! -d "$RDC_BUILD_DIR/rdc_libs" ]; then
+        mkdir -p $RDC_BUILD_DIR
+        pushd $RDC_BUILD_DIR
+        cmake \
+            -DGRPC_ROOT="$GRPC_PROTOC_ROOT" \
+            -DGRPC_DESIRED_VERSION="$GRPC_DESIRED_VERSION" \
+            -DCMAKE_MODULE_PATH="$RDC_ROOT/cmake_modules" \
+            $(rocm_cmake_params) \
+            $(rdc_backwards_compat_cmake_params) \
+            $(rocm_common_cmake_params) \
+            -DROCM_DIR=$ROCM_INSTALL_PATH \
+            -DRDC_PACKAGE="${RDC_PKG_NAME}" \
+            -DCPACK_PACKAGE_VERSION_MAJOR="1" \
+            -DCPACK_PACKAGE_VERSION_MINOR="$ROCM_LIBPATCH_VERSION" \
+            -DCPACK_PACKAGE_VERSION_PATCH="0" \
+            -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+            -DBUILD_TESTS=ON \
+            -DCMAKE_SKIP_BUILD_RPATH=TRUE \
+            -DCMAKE_EXE_LINKER_FLAGS_INIT="-Wl,--no-as-needed,-z,origin,--enable-new-dtags,--build-id=sha1,--rpath,$RDC_EXE_RPATH" \
+            -DCMAKE_SHARED_LINKER_FLAGS_INIT="-Wl,--no-as-needed,-z,origin,--enable-new-dtags,--build-id=sha1,--rpath,$RDC_LIB_RPATH" \
+            "$RDC_ROOT"
+        popd
+    fi
+    echo "Making rdc package:"
+    cmake --build "$RDC_BUILD_DIR" -- $RDC_MAKE_OPTS
+    cmake --build "$RDC_BUILD_DIR" -- $RDC_MAKE_OPTS install
+
+    unset LD_PRELOAD
+    cmake --build "$RDC_BUILD_DIR" -- $RDC_MAKE_OPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$RDC_PACKAGE_DEB_DIR" "$RDC_BUILD_DIR/$RDC_PKG_NAME"*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$RDC_PACKAGE_RPM_DIR" "$RDC_BUILD_DIR/$RDC_PKG_NAME"*.rpm
+
+    if [ ! -e $ROCM_INSTALL_PATH/include/rdc/rdc.h ]; then
+      cp -r "$ROCM_INSTALL_PATH/rdc/lib/." "$PACKAGE_LIB"
+      cp -r "$ROCM_INSTALL_PATH/rdc/bin/." "$PACKAGE_BIN"
+      cp -r "$ROCM_INSTALL_PATH/rdc/include/." "$PACKAGE_INCLUDE"
+    fi
+
+    if [ "$BUILD_DOCS" = "yes" ]; then
+      echo "Building Docs"
+      cmake --build "$RDC_BUILD_DIR" -- $RDC_MAKE_OPTS doc
+      pushd $RDC_BUILD_DIR/latex
+      cmake --build . --
+      mv refman.pdf "$ROCM_INSTALL_PATH/rdc/RDC_Manual.pdf"
+      popd
+    fi
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${RDC_PACKAGE_DEB_DIR};;
+        ("rpm")
+            echo ${RDC_PACKAGE_RPM_DIR};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean_rdc ;;
+    (clean_grpc) clean_grpc ;;
+    (build) build_grpc; build_rdc ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocalution.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+PATH=${ROCM_PATH}/bin:$PATH
+set_component_src rocALUTION
+
+build_rocalution() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    CXX="g++"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+        set_asan_env_vars
+        set_address_sanitizer_on
+    fi
+
+    echo "C compiler: $CC"
+    echo "CXX compiler: $CXX"
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    cmake \
+        -DSUPPORT_HIP=ON \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip;${ROCM_PATH}/hip/cmake" \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocalution() {
+    echo "Cleaning rocALUTION build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocalution ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocalution ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocblas.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rocBLAS
+DEPS_DIR=${HOME}/rocblas
+
+stage2_command_args "$@"
+
+build_rocblas() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+       export ASAN_OPTIONS="detect_leaks=0:verify_asan_link_order=0"
+    fi
+
+    cd $COMPONENT_SRC
+
+    mkdir -p $DEPS_DIR && cp -r /usr/blis $DEPS_DIR
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    cmake \
+        -DCMAKE_TOOLCHAIN_FILE=toolchain-linux.cmake \
+        -DBUILD_DIR="${BUILD_DIR}" \
+        $(rocm_common_cmake_params) \
+        -DROCM_DIR="${ROCM_PATH}" \
+        ${LAUNCHER_FLAGS} \
+        -DCMAKE_PREFIX_PATH="${DEPS_DIR};${ROCM_PATH}" \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DLINK_BLIS=ON \
+        -DAMDGPU_TARGETS="${GPU_TARGETS}" \
+        -DTensile_CODE_OBJECT_VERSION=default \
+        -DTensile_LOGIC=asm_full \
+        -DTensile_SEPARATE_ARCHITECTURES=ON \
+        -DTensile_LAZY_LIBRARY_LOADING=ON \
+        -DTensile_LIBRARY_FORMAT=msgpack \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        -DTENSILE_VENV_UPGRADE_PIP=ON \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && rm -rf ./library/src/build_tmp && find -name '*.o' -delete
+
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocblas() {
+    echo "Cleaning rocBLAS build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+case $TARGET in
+    build) build_rocblas ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocblas ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocclr.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...] [make options]"
+    echo
+    echo "Options:"
+    echo "  -h,  --help               Prints this help"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of type referred to by pkg_type"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+MAKEOPTS="$DASH_JAY"
+
+BUILD_PATH="$(getBuildPath rocclr)"
+
+TARGET="build"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_DEB="$(getPackageRoot)/deb/rocclr"
+PACKAGE_RPM="$(getPackageRoot)/rpm/rocclr"
+CORE_BUILD_DIR="$(getBuildPath hsa-core)"
+BUILD_TYPE="Debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso: --long help,clean,release,static,address_sanitizer,outdir: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_rocclr() {
+    rm -rf "$BUILD_PATH"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+}
+
+build_rocclr() {
+    if [ "$SHARED_LIBS" = "ON" ]; then
+        echo "rocclr not a standalone repo. skipping build" >&2
+        echo "rocclr not a standalone repo. skipping build"
+        exit 0
+    fi
+
+    if [ ! -e "$CLR_ROOT/CMakeLists.txt" ]; then
+        _ROCclr_CMAKELIST_DIR="$CLR_ROOT"
+    elif [ ! -e "$ROCclr_ROOT/CMakeLists.txt" ]; then
+        echo "No $ROCclr_ROOT/CMakeLists.txt file, skipping rocclr" >&2
+        echo "No $ROCclr_ROOT/CMakeLists.txt file, skipping rocclr"
+        exit 0
+    else
+        _ROCclr_CMAKELIST_DIR="$ROCclr_ROOT"
+    fi
+    echo "$_ROCclr_CMAKELIST_DIR"
+    mkdir -p "$BUILD_PATH"
+    pushd "$BUILD_PATH"
+    print_lib_type $SHARED_LIBS
+    if [ ! -e Makefile ]; then
+        echo "Building ROCclr CMake environment"
+
+        cmake -DUSE_COMGR_LIBRARY=ON \
+            $(rocm_cmake_params) \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            -DLLVM_INCLUDES="$LLVM_ROOT/include" \
+            $(rocm_common_cmake_params) \
+            "$_ROCclr_CMAKELIST_DIR"
+
+        echo "CMake complete"
+    fi
+
+    echo "Building ROCclr"
+    cmake --build . -- $MAKEOPTS "VERBOSE=1"
+
+    popd
+}
+
+case $TARGET in
+    (clean) clean_rocclr ;;
+    (build) build_rocclr ;;
+    (outdir) exit ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocdecode.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+set_component_src rocDecode
+BUILD_DEV=ON
+build_rocdecode() {
+    if [ "$DISTRO_ID" = "centos-7" ] ; then
+     echo "Not building rocDecode for ${DISTRO_ID}. Exiting..." 
+     return 0
+    fi
+
+    echo "Start build"
+    mkdir -p $BUILD_DIR && cd $BUILD_DIR
+    
+    cmake ${COMPONENT_SRC}
+    make -j8
+    make install
+    make package
+    
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cpack -G ${PKGTYPE^^} -B ${BUILD_DIR}
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR
+    cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+    show_build_cache_stats
+}
+clean_rocdecode() {
+    echo "Cleaning rocDecode build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+stage2_command_args "$@"
+case $TARGET in
+    build) build_rocdecode ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocdecode ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocfft.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+PATH=${ROCM_PATH}/bin:$PATH
+set_component_src rocFFT
+
+build_rocfft() {
+    echo "Start Build"
+
+    cd $COMPONENT_SRC
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+    fi
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX="${ROCM_PATH}/bin/hipcc" \
+    cmake \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DUSE_HIP_CLANG=ON \
+        -DHIP_COMPILER=clang  \
+        -DBUILD_CLIENTS_SAMPLES=ON  \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_RIDER=ON  \
+        -DCPACK_SET_DESTDIR=OFF  \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocfft() {
+    echo "Cleaning rocFFT build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocfft ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocfft ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocm-cmake.sh

@@ -0,0 +1,121 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -r,  --release            Build a release version of the package"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -h,  --help             Prints this help"
+    echo
+    echo
+
+    return 0
+}
+
+TARGET="build"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_DEB="$(getPackageRoot)/deb/rocm-cmake"
+PACKAGE_RPM="$(getPackageRoot)/rpm/rocm-cmake"
+ROCM_CMAKE_BUILD_DIR="$(getBuildPath rocm-cmake)"
+
+ROCM_CMAKE_BUILD_DIR="$(getBuildPath rocm-cmake)"
+ROCM_CMAKE_PACKAGE_DEB="$(getPackageRoot)/deb/rocm-cmake"
+ROCM_CMAKE_PACKAGE_RPM="$(getPackageRoot)/rpm/rocm-cmake"
+ROCM_CMAKE_BUILD_TYPE="debug"
+BUILD_TYPE="Debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+PKGTYPE="deb"
+MAKETARGET="deb"
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                ack_and_ignore_asan ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_rocm_cmake() {
+    rm -rf $ROCM_CMAKE_BUILD_DIR
+    rm -rf $ROCM_CMAKE_PACKAGE_DEB
+    rm -rf $ROCM_CMAKE_PACKAGE_RPM
+}
+
+build_rocm_cmake() {
+    echo "Building ROCm cmake"
+
+    if [ ! -d "$ROCM_CMAKE_BUILD_DIR" ]; then
+        mkdir -p "$ROCM_CMAKE_BUILD_DIR"
+        pushd "$ROCM_CMAKE_BUILD_DIR"
+
+        cmake \
+            $(rocm_cmake_params) \
+            -DCPACK_SET_DESTDIR="OFF" \
+            -DROCM_DISABLE_LDCONFIG=ON \
+            $ROCM_CMAKE_ROOT
+        cmake --build . -- install
+        cmake --build . -- package
+        popd
+    fi
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$ROCM_CMAKE_PACKAGE_DEB" $ROCM_CMAKE_BUILD_DIR/rocm-cmake*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$ROCM_CMAKE_PACKAGE_RPM" $ROCM_CMAKE_BUILD_DIR/rocm-cmake*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${ROCM_CMAKE_PACKAGE_DEB};;
+        ("rpm")
+            echo ${ROCM_CMAKE_PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+case $TARGET in
+    (clean) clean_rocm_cmake ;;
+    (build) build_rocm_cmake ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocm-core.sh

@@ -0,0 +1,131 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+                                      type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+PACKAGE_ROOT="$(getPackageRoot)"
+ROCM_CORE_BUILD_DIR="$(getBuildPath rocm_core)"
+ROCM_CORE_PACKAGE_DEB="$(getPackageRoot)/deb/rocm-core"
+ROCM_CORE_PACKAGE_RPM="$(getPackageRoot)/rpm/rocm-core"
+ROCM_CORE_MAKE_OPTS="$DASH_JAY -C $ROCM_CORE_BUILD_DIR"
+BUILD_TYPE="Debug"
+TARGET="build"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+ADDRESS_SANITIZER=false
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on
+                ADDRESS_SANITIZER=true ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package )
+                MAKETARGET=$2 ; shift 2 ;;
+        --)     shift; break;; # end delimiter
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_rocm_core() {
+    rm -rf "$ROCM_CORE_BUILD_DIR"
+    rm -rf "$ROCM_CORE_PACKAGE_DEB"
+    rm -rf "$ROCM_CORE_PACKAGE_RPM"
+}
+
+build_rocm_core() {
+    echo "Building rocm-core "
+
+    if [ ! -d "$ROCM_CORE_BUILD_DIR" ]; then
+       mkdir -p "$ROCM_CORE_BUILD_DIR"
+    fi
+
+    pushd "$ROCM_CORE_BUILD_DIR"
+    cmake \
+            -DCMAKE_VERBOSE_MAKEFILE=1 \
+            $(rocm_common_cmake_params) \
+            -DCMAKE_INSTALL_PREFIX="$ROCM_INSTALL_PATH" \
+            -DCPACK_PACKAGING_INSTALL_PREFIX="$ROCM_INSTALL_PATH" \
+            -DCPACK_GENERATOR="${CPACKGEN:-"DEB;RPM"}" \
+            -DCPACK_DEBIAN_PACKAGE_RELEASE=$CPACK_DEBIAN_PACKAGE_RELEASE \
+            -DCPACK_RPM_PACKAGE_RELEASE=$CPACK_RPM_PACKAGE_RELEASE \
+            -DROCM_VERSION="$ROCM_VERSION" \
+            -DBUILD_ID="$BUILD_ID" \
+            $ROCM_CORE_ROOT
+
+    make && make install && make package
+    popd
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$ROCM_CORE_PACKAGE_DEB" $ROCM_CORE_BUILD_DIR/rocm*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$ROCM_CORE_PACKAGE_RPM" $ROCM_CORE_BUILD_DIR/rocm*.rpm
+}
+
+print_output_directory() {
+     case ${PKGTYPE} in
+         ("deb")
+             echo ${ROCM_CORE_PACKAGE_DEB};;
+         ("rpm")
+             echo ${ROCM_CORE_PACKAGE_RPM};;
+         (*)
+             echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+     esac
+     exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean_rocm_core ;;
+    (build) build_rocm_core ;;
+    (outdir) print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocm-dev.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) echo "end of rocm-dev build..." ;;
+    outdir) ;;
+    clean) echo "Cleaning rocm-dev is not required..." ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocm-gdb.sh

@@ -0,0 +1,437 @@
+#!/bin/bash
+
+source "${BASH_SOURCE%/*}/compute_utils.sh" || return
+
+remove_make_r_flags
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+            type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+toStdoutStderr(){
+    printf '%s\n' "$@" >&2
+    printf '%s\n' "$@"
+}
+
+linkFiles(){
+    cp -lfR "$1" "$2" || cp -fR "$1" "$2"
+}
+
+PROJ_NAME=rocm-gdb
+TARGET=build
+MAKETARGET=deb
+BUILD_DIR=$(getBuildPath $PROJ_NAME)
+PACKAGE_DEB=$(getPackageRoot)/deb/$PROJ_NAME
+PACKAGE_RPM=$(getPackageRoot)/rpm/$PROJ_NAME
+MAKE_OPTS="$DASH_JAY"
+BUG_URL="https://github.com/ROCm-Developer-Tools/ROCgdb/issues"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+LDFLAGS="$LDFLAGS -Wl,--enable-new-dtags"
+
+
+tokeep=(
+    main${ROCM_INSTALL_PATH}/bin/rocgdb
+    main${ROCM_INSTALL_PATH}/bin/roccoremerge
+    main${ROCM_INSTALL_PATH}/share/rocgdb/python/gdb/.*
+    main${ROCM_INSTALL_PATH}/share/rocgdb/syscalls/amd64-linux.xml
+    main${ROCM_INSTALL_PATH}/share/rocgdb/syscalls/gdb-syscalls.dtd
+    main${ROCM_INSTALL_PATH}/share/rocgdb/syscalls/i386-linux.xml
+    main${ROCM_INSTALL_PATH}/share/doc/rocgdb/NOTICES.txt
+    main${ROCM_INSTALL_PATH}/share/doc/rocgdb/rocannotate.pdf
+    main${ROCM_INSTALL_PATH}/share/doc/rocgdb/rocgdb.pdf
+    main${ROCM_INSTALL_PATH}/share/doc/rocgdb/rocrefcard.pdf
+    main${ROCM_INSTALL_PATH}/share/doc/rocgdb/rocstabs.pdf
+    main${ROCM_INSTALL_PATH}/share/info/rocgdb/dir
+    main${ROCM_INSTALL_PATH}/share/info/rocgdb/annotate.info
+    main${ROCM_INSTALL_PATH}/share/info/rocgdb/gdb.info
+    main${ROCM_INSTALL_PATH}/share/info/rocgdb/stabs.info
+    main${ROCM_INSTALL_PATH}/share/man/man1/rocgdb.1
+    main${ROCM_INSTALL_PATH}/share/man/man1/roccoremerge.1
+    main${ROCM_INSTALL_PATH}/share/man/man5/rocgdbinit.5
+    main${ROCM_INSTALL_PATH}/share/html/rocannotate/.*
+    main${ROCM_INSTALL_PATH}/share/html/rocgdb/.*
+    main${ROCM_INSTALL_PATH}/share/html/rocstabs/.*
+)
+
+keep_wanted_files(){
+    (
+        cd "$BUILD_DIR/package/"
+        printf -v keeppattern '%s\n' "${tokeep[@]}"
+        find main/opt -type f | grep -xv "$keeppattern" | xargs -r rm
+        find main/opt -type d -empty -delete
+    )
+    return 0
+}
+
+copy_testsuite_files() {
+(
+dest="$BUILD_DIR/package/tests${ROCM_INSTALL_PATH}/test/gdb/"
+cd "$ROCM_GDB_ROOT"
+find \
+    config.guess \
+    config.sub \
+    contrib/dg-extract-results.py \
+    contrib/dg-extract-results.sh \
+    gdb/contrib \
+    gdb/disable-implicit-rules.mk \
+    gdb/features \
+    gdb/silent-rules.mk \
+    gdb/testsuite \
+    include/dwarf2.def \
+    include/dwarf2.h \
+    install-sh \
+    -print0 | cpio -pdu0 "$dest"
+)
+}
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+
+    rm -rf $BUILD_DIR
+    rm -rf $PACKAGE_DEB
+    rm -rf $PACKAGE_RPM
+}
+
+get_version(){
+    VERSION=$(sed -n 's/^.*char version[^"]*"\([^"]*\)".*;.*/\1/p' $BUILD_DIR/gdb/version.c || : )
+    VERSION=${VERSION:-$1}
+}
+
+package_deb(){
+    mkdir -p "$BUILD_DIR/package/main/DEBIAN"
+    local VERSION
+    get_version unknown
+    VERSION="${VERSION}.${ROCM_LIBPATCH_VERSION}"
+
+    grep -v '^# ' > "$BUILD_DIR/package/main/DEBIAN/control" <<EOF
+# Required fields
+Version: ${VERSION}-${CPACK_DEBIAN_PACKAGE_RELEASE}
+Package: ${PROJ_NAME}
+Maintainer: ROCm Debugger Support <rocm-gdb.support@amd.com>
+Description: ROCgdb
+ This is ROCgdb, the AMD ROCm source-level debugger for Linux,
+ based on GDB, the GNU source-level debugger.
+# Optional fields
+Section: utils
+Architecture: amd64
+Essential: no
+Priority: optional
+Depends: libexpat1, libtinfo5, libncurses5, rocm-dbgapi, libpython3.10 | libpython3.8, libbabeltrace-ctf1 (>= 1.2.1), libbabeltrace1 (>= 1.2.1), rocm-core
+EOF
+
+    mkdir -p "$OUT_DIR/deb/$PROJ_NAME"
+    fakeroot dpkg-deb -Zgzip --build "$BUILD_DIR/package/main" "$OUT_DIR/deb/$PROJ_NAME"
+
+    mkdir -p "$BUILD_DIR/package/tests/DEBIAN"
+    mkdir -p "$BUILD_DIR/package/tests/${ROCM_INSTALL_PATH}/test/gdb"
+
+    grep -v '^# ' > "$BUILD_DIR/package/tests/DEBIAN/control" <<EOF
+# Required fields
+Version: ${VERSION}-${CPACK_DEBIAN_PACKAGE_RELEASE}
+Package: ${PROJ_NAME}-tests
+Maintainer: ROCm Debugger Support <rocm-gdb.support@amd.com>
+Description: ROCgdb tests
+ Test Suite for ROCgdb
+# Optional fields
+Section: utils
+Architecture: amd64
+Essential: no
+Priority: optional
+# rocm-core as policy says everything to depend on rocm-core
+Depends: ${PROJ_NAME} (=${VERSION}-${CPACK_DEBIAN_PACKAGE_RELEASE}), dejagnu, rocm-core, make
+EOF
+
+    copy_testsuite_files
+    fakeroot dpkg-deb -Zgzip --build "$BUILD_DIR/package/tests" "$OUT_DIR/deb/$PROJ_NAME"
+}
+
+package_rpm(){
+    set -- rocm-gdb
+    local packageDir="$BUILD_DIR/package_rpm/$1"
+    local specFile="$packageDir/$1.spec"
+    local packageRpm="$packageDir/rpm"
+
+    local VERSION
+    get_version 0.0.0
+
+    VERSION=${VERSION}.${ROCM_LIBPATCH_VERSION}
+
+    local ospost="$(echo '%define __os_install_post \'
+                    rpm --showrc | sed '1,/^-14: __os_install_post/d;
+                                       /^-14:/,$d;/^%{nil}/!s/$/ \\/;
+                                       /brp-python-bytecompile/d')"
+
+    echo "specFile:        $specFile"
+    echo "packageRpm:      $packageRpm"
+
+    mkdir -p "$packageDir"
+
+    grep -v '^## ' <<- EOF > $specFile
+## Set up where this stuff goes
+%define _topdir $packageRpm
+%define _rpmfilename %%{ARCH}/%%{NAME}-${VERSION}-${CPACK_RPM_PACKAGE_RELEASE}%{?dist}.%%{ARCH}.rpm
+## The __os_install_post macro on centos creates .pyc and .pyo objects
+## by calling brp-python-bytecompile
+## This then creates an issue as the script doesn't package these files
+## override it
+$ospost
+##
+Name: ${PROJ_NAME}
+Group: Development/Tools/Debuggers
+Summary: ROCm source-level debugger for Linux
+## rpm requires the version to be dot separated numbers
+Version: ${VERSION//-/_}
+Release: ${CPACK_RPM_PACKAGE_RELEASE}%{?dist}
+License: GPL
+Requires: rocm-core
+
+%description
+This is ROCgdb, the ROCm source-level debugger for Linux, based on
+GDB, the GNU source-level debugger.
+
+The ROCgdb documentation is available at:
+https://github.com/RadeonOpenCompute/ROCm
+
+## these things are commented out as they are not needed, but are
+## left in for documentation.
+# %prep
+# : Should not need to do anything in prep
+# %build
+# : Should not need to do anything in build as make does that
+# %clean
+# : Should not need to do anything in clean
+## This is the meat. Get a copy of the files from where we built them
+## into the local RPM_BUILD_ROOT and left the defaults take over. Need
+## to quote the dollar signs as we want rpm to expand them when it is
+## run, rather than the shell when we build the spec file.
+%install
+rm -rf \$RPM_BUILD_ROOT
+mkdir -p \$RPM_BUILD_ROOT
+# Get a copy of the built tree.
+cp -ar $BUILD_DIR/package/main/opt \$RPM_BUILD_ROOT/opt
+## The file section is generated by walking the tree.
+%files
+EOF
+
+    find $BUILD_DIR/package/main/opt -type d | sed "s:$BUILD_DIR/package/main:%dir :" >> $specFile
+    find $BUILD_DIR/package/main/opt ! -type d | sed "s:$BUILD_DIR/package/main::" >> $specFile
+
+    rpmbuild --define "_topdir $packageRpm" -ba $specFile
+
+    mkdir -p "$PACKAGE_RPM"        # e.g. out/ubuntu-16.04/16.04/rpm/rocm-gdb
+    mv $packageRpm/RPMS/x86_64/*.rpm "$PACKAGE_RPM"
+}
+
+package_rpm_tests(){
+    set -- rocm-gdb-tests
+    local packageDir="$BUILD_DIR/package_rpm/$1"
+    local specFile="$packageDir/$1.spec"
+    local packageRpm="$packageDir/rpm"
+
+    local VERSION
+    get_version 0.0.0
+    VERSION=${VERSION}.${ROCM_LIBPATCH_VERSION}
+    local RELEASE=${CPACK_RPM_PACKAGE_RELEASE}%{?dist}
+
+    echo "specFile:        $specFile"
+    echo "packageRpm:      $packageRpm"
+
+    mkdir -p "$packageRpm"
+
+    local ospost="$(echo '%define __os_install_post \'
+                    rpm --showrc | sed '1,/^-14: __os_install_post/d;
+                                       /^-14:/,$d;/^%{nil}/!s/$/ \\/;
+                                       /brp-python-bytecompile/d')"
+    grep -v '^## ' <<- EOF > $specFile
+## Set up where this stuff goes
+%define _topdir $packageRpm
+%define _rpmfilename %%{ARCH}/%%{NAME}-${VERSION}-${RELEASE}.%%{ARCH}.rpm
+## The __os_install_post macro on centos creates .pyc and .pyo objects
+## by calling brp-python-bytecompile
+## This then creates an issue as the script doesn't package these files
+## override it
+$ospost
+##
+Name: ${PROJ_NAME}-tests
+Group: Development/Tools/Debuggers
+Summary: Tests for gdb enhanced to debug AMD GPUs
+Version: ${VERSION//-/_}
+Release: ${RELEASE}
+License: GPL
+Requires: dejagnu, ${PROJ_NAME} = ${VERSION//-/_}-${RELEASE}, rocm-core, make
+
+%description
+Tests for ROCgdb
+
+## these things are commented out as they are not needed, but are
+## left in for documentation.
+# %prep
+# : Should not need to do anything in prep
+# %build
+# : Should not need to do anything in build as make does that
+# %clean
+# : Should not need to do anything in clean
+## This is the meat. Get a copy of the files from where we built them
+## into the local RPM_BUILD_ROOT and left the defaults take over. Need
+## to quote the dollar signs as we want rpm to expand them when it is
+## run, rather than the shell when we build the spec file.
+%install
+rm -rf \$RPM_BUILD_ROOT
+mkdir -p \$RPM_BUILD_ROOT
+# Get a copy of the built tree.
+cp -ar $BUILD_DIR/package/tests/opt \$RPM_BUILD_ROOT/opt
+## The file section is generated by walking the tree.
+%files
+## package everything in \$RPM_BUILD_ROOT/${ROCM_INSTALL_PATH}/test.
+## A little excessive but this is just an internal test package
+${ROCM_INSTALL_PATH}/test
+EOF
+
+    copy_testsuite_files
+
+    find $BUILD_DIR/package/tests/opt -type f -exec sed -i '1s:^#! */usr/bin/python\>:&3:' {} +
+
+    rpmbuild --define "_topdir $packageRpm" -ba $specFile
+    mkdir -p "$PACKAGE_RPM"
+    mv $packageRpm/RPMS/x86_64/*.rpm "$PACKAGE_RPM"
+}
+
+build() {
+    if [ ! -e "$ROCM_GDB_ROOT/configure" ]
+    then
+        toStdoutStderr "No $ROCM_GDB_ROOT/configure file, skippping rocm-gdb"
+        exit 0
+    fi
+    local pythonver=python3
+    if [[ "$DISTRO_ID" == "ubuntu-18.04" ]]; then
+        pythonver=python3.8
+    fi
+
+    if [[ "$DISTRO_ID" == "centos-9" ]] || [[ "$DISTRO_ID" == "rhel-9.0" ]]; then
+        fmtutil-user --missing
+    fi
+    echo "Building $PROJ_NAME"
+    mkdir -p "$BUILD_DIR"
+    cd "$BUILD_DIR" || die "Failed to cd to '$BUILD_DIR'"
+
+    $ROCM_GDB_ROOT/configure --program-prefix=roc --prefix="${ROCM_INSTALL_PATH}" \
+	--htmldir="\${prefix}/share/html" --pdfdir="\${prefix}/share/doc/rocgdb" \
+	--infodir="\${prefix}/share/info/rocgdb" \
+	--with-separate-debug-dir="\${prefix}/lib/debug:/usr/lib/debug" \
+	--with-gdb-datadir="\${prefix}/share/rocgdb" --enable-64-bit-bfd \
+        --with-bugurl="$BUG_URL" --with-pkgversion="${ROCM_BUILD_ID:-ROCm}" \
+        --enable-targets="x86_64-linux-gnu,amdgcn-amd-amdhsa" \
+        --disable-ld --disable-gas --disable-gdbserver --disable-sim --enable-tui \
+        --disable-gdbtk --disable-shared --disable-gprofng \
+        --with-expat --with-system-zlib --without-guile --with-babeltrace --with-lzma \
+        --with-python=$pythonver --with-rocm-dbgapi=$ROCM_INSTALL_PATH \
+        --with-amd-dbgapi PKG_CONFIG_PATH="${ROCM_INSTALL_PATH}/share/pkgconfig" \
+	LDFLAGS="$LDFLAGS"
+    LD_RUN_PATH='${ORIGIN}/../lib' make $MAKE_OPTS
+    mkdir -p $BUILD_DIR/package/main${ROCM_INSTALL_PATH}/{share/rocgdb,bin}
+
+    make $MAKE_OPTS -C gdb DESTDIR=$BUILD_DIR/package/main install install-pdf install-html
+
+    make $MAKE_OPTS -C binutils DESTDIR=$BUILD_DIR/package/main install
+
+    linkFiles $ROCM_GDB_ROOT/gdb/NOTICES.txt $BUILD_DIR/package/main${ROCM_INSTALL_PATH}/share/doc/rocgdb
+    keep_wanted_files
+
+    [ "${CPACKGEN}" = "DEB" ] || package_rpm && package_rpm_tests
+    [ "${CPACKGEN}" = "RPM" ] || package_deb
+}
+
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+main(){
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ; MAKEARG="$MAKEARG REL=1" ;; # For compatability with other scripts
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)                 #FIXME
+                MAKETARGET="$2" ; shift 2;;
+        # I think it would be better to use -- to indicate end of args
+        # and insert an error message about unknown args at this point.
+        --)     shift; break;; # end delimiter
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+done
+
+if [[ $CXX == *"clang++" ]]
+then
+    CXX="$CXX -std=gnu++17"
+fi
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+    case $TARGET in
+        ("clean") clean ;;
+        ("build") build ;;
+        ("outdir") print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+    esac
+    echo "Operation complete"
+}
+
+if [ "$0" = "$BASH_SOURCE" ]
+then
+    main "$@"
+else
+    set +e
+fi

tools/rocm-build/build_rocm_bandwidth_test.sh

@@ -0,0 +1,155 @@
+#!/bin/bash -x
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -s,  --static           Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+        type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+TEST_BIN_DIR="$(getBinPath)"
+TEST_NAME="rocm-bandwidth-test"
+TEST_UTILS_DIR="$(getUtilsPath)"
+TEST_SRC_DIR="rocm_bandwidth_test"
+TEST_BLD_DIR="$(getBuildPath $TEST_SRC_DIR)"
+
+ROCM_PKG_PREFIX="$ROCM_INSTALL_PATH"
+TEST_PKG_ROOT="$(getPackageRoot)"
+TEST_PKG_DEB="$(getPackageRoot)/deb/$TEST_SRC_DIR"
+TEST_PKG_RPM="$(getPackageRoot)/rpm/$TEST_SRC_DIR"
+
+ROCR_LIB_DIR="$(getPackageRoot)/lib"
+ROCR_INC_DIR="$(getPackageRoot)/hsa/include"
+
+RUN_SCRIPT=$(echo $(basename "${BASH_SOURCE}") | sed "s/build_/run_/")
+
+TARGET="build"
+MAKETARGET="all"
+BUILD_TYPE="Debug"
+MAKEARG="$DASH_JAY"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; MAKEARG="$MAKEARG REL=1" ;  shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; CPACKGEN="${2^^}" ; shift 2;;
+        --)     shift; break;; # end delimiter
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_rocm_bandwidth_test() {
+    echo "Cleaning $TEST_NAME"
+
+    rm -rf $TEST_BLD_DIR
+    rm -rf $TEST_PKG_DEB
+    rm -rf $TEST_PKG_RPM
+    rm -rf $TEST_BIN_DIR/$TEST_NAME
+    rm -f  $TEST_UTILS_DIR/$RUN_SCRIPT
+}
+
+build_rocm_bandwidth_test() {
+
+    echo "Building $TEST_NAME"
+
+    if [ ! -d "$TEST_BLD_DIR" ]; then
+        mkdir -p "$TEST_BLD_DIR"
+        pushd "$TEST_BLD_DIR"
+
+        cmake \
+            -DCMAKE_BUILD_TYPE="$BUILD_TYPE"      \
+            -DCMAKE_VERBOSE_MAKEFILE=1 \
+            -DCMAKE_INSTALL_PREFIX="$TEST_PKG_ROOT" \
+            -DCPACK_PACKAGING_INSTALL_PREFIX="$ROCM_INSTALL_PATH" \
+            -DCMAKE_PREFIX_PATH="$ROCM_INSTALL_PATH" \
+	    $(rocm_common_cmake_params) \
+            -DCPACK_GENERATOR="${CPACKGEN:-"DEB;RPM"}" \
+            -DROCM_PATCH_VERSION=$ROCM_LIBPATCH_VERSION \
+            -DCMAKE_MODULE_PATH="$ROCM_BANDWIDTH_TEST_ROOT/cmake_modules" \
+            -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+            "$ROCM_BANDWIDTH_TEST_ROOT"
+
+        popd
+    fi
+
+    echo "Building $TEST_NAME"
+    cmake --build "$TEST_BLD_DIR" -- $MAKEARG -C $TEST_BLD_DIR
+
+    echo "Installing $TEST_NAME"
+    cmake --build "$TEST_BLD_DIR" -- $MAKEARG -C $TEST_BLD_DIR install
+
+    echo "Packaging $TEST_NAME"
+    cmake --build "$TEST_BLD_DIR" -- $MAKEARG -C $TEST_BLD_DIR package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$TEST_PKG_DEB" $TEST_BLD_DIR/*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$TEST_PKG_RPM" $TEST_BLD_DIR/*.rpm
+
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${TEST_PKG_DEB};;
+        ("rpm")
+            echo ${TEST_PKG_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean_rocm_bandwidth_test ;;
+    (build) build_rocm_bandwidth_test ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocm_smi_lib.sh

@@ -0,0 +1,153 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [-c|-r|-32|-h] [makeopts]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Removes all rocm_smi build artifacts"
+    echo "  -r,  --release            Build non-debug version rocm_smi (default is debug)"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of type referred to by pkg_type"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -32,                      Build 32b version (default is 64b)"
+    echo "  -h,  --help             Prints this help"
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+PACKAGE_ROOT="$(getPackageRoot)"
+TARGET="build"
+
+PACKAGE_LIB=$(getLibPath)
+PACKAGE_INCLUDE="$(getIncludePath)"
+
+RSMI_BUILD_DIR=$(getBuildPath rsmi)
+RSMI_PACKAGE_DEB_DIR="$(getPackageRoot)/deb/rsmi"
+RSMI_PACKAGE_RPM_DIR="$(getPackageRoot)/rpm/rsmi"
+RSMI_BUILD_TYPE="debug"
+BUILD_TYPE="Debug"
+
+MAKETARGET="deb"
+MAKEARG="$DASH_JAY O=$RSMI_BUILD_DIR"
+RSMI_MAKE_OPTS="$DASH_JAY O=$RSMI_BUILD_DIR -C $RSMI_BUILD_DIR"
+ROCM_SMI_BLD_BITS=64
+RSMI_PKG_NAME_ROOT="rocm-smi-lib"
+RSMI_PKG_NAME="${RSMI_PKG_NAME_ROOT}${ROCM_SMI_BLD_BITS}"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+PKGTYPE="deb"
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on
+                # TODO - support standard option of passing cmake environment vars - CFLAGS,CXXFLAGS etc., to enable address sanitizer
+                ADDRESS_SANITIZER=true ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        (-32)
+                ROCM_SMI_BLD_BITS="32"; shift ;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean_rsmi() {
+    rm -rf "$RSMI_BUILD_DIR"
+    rm -rf "$RSMI_PACKAGE_DEB_DIR"
+    rm -rf "$RSMI_PACKAGE_RPM_DIR"
+    rm -rf "$PACKAGE_ROOT/rocm_smi"
+    rm -rf "$PACKAGE_INCLUDE/rocm_smi"
+    rm -f $PACKAGE_LIB/librocm_smi${ROCM_SMI_BLD_BITS}.*
+    rm -f $PACKAGE_LIB/librocm_smi${ROCM_SMI_BLD_BITS}.*
+    return 0
+}
+
+build_rsmi() {
+    echo "Building RSMI"
+    echo "RSMI_BUILD_DIR: ${RSMI_BUILD_DIR}"
+    if [ ! -d "$RSMI_BUILD_DIR" ]; then
+        mkdir -p $RSMI_BUILD_DIR
+        pushd $RSMI_BUILD_DIR
+        print_lib_type $SHARED_LIBS
+
+        cmake \
+            -DCMAKE_MODULE_PATH="$ROCM_SMI_LIB_ROOT/cmake_modules" \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+	    $(rocm_common_cmake_params) \
+            $(rocm_cmake_params) \
+            -DENABLE_LDCONFIG=OFF \
+            -DROCM_SMI_PACKAGE="${RSMI_PKG_NAME}" \
+            -DCPACK_PACKAGE_VERSION_MAJOR="1" \
+            -DCPACK_PACKAGE_VERSION_MINOR="$ROCM_LIBPATCH_VERSION" \
+            -DCPACK_PACKAGE_VERSION_PATCH="0" \
+            -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+            -DBUILD_TESTS=ON \
+            "$ROCM_SMI_LIB_ROOT"
+        popd
+    fi
+
+    echo "Making rocm_smi package:"
+    cmake --build "$RSMI_BUILD_DIR" -- $RSMI_MAKE_OPTS
+    cmake --build "$RSMI_BUILD_DIR" -- $RSMI_MAKE_OPTS install
+    cmake --build "$RSMI_BUILD_DIR" -- $RSMI_MAKE_OPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$RSMI_PACKAGE_DEB_DIR" $RSMI_BUILD_DIR/*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$RSMI_PACKAGE_RPM_DIR" $RSMI_BUILD_DIR/*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${RSMI_PACKAGE_DEB_DIR};;
+        ("rpm")
+            echo ${RSMI_PACKAGE_RPM_DIR};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean_rsmi ;;
+    (build) build_rsmi ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"
+exit 0

tools/rocm-build/build_rocminfo.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [-c|-r|-h] [makeopts]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Removes all rocminfo build artifacts"
+    echo "  -r,  --release            Build non-debug version rocminfo (default is debug)"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -s,  --static             Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+                                      type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "Possible values for <pkg_type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+
+TARGET="build"
+ROCMINFO_DEST="$(getBinPath)"
+ROCMINFO_SRC_ROOT="$ROCMINFO_ROOT"
+ROCMINFO_BUILD_DIR="$(getBuildPath rocminfo)"
+
+MAKEARG="$DASH_JAY"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_UTILS="$(getUtilsPath)"
+ROCMINFO_PACKAGE_DEB="$(getPackageRoot)/deb/rocminfo"
+ROCMINFO_PACKAGE_RPM="$(getPackageRoot)/rpm/rocminfo"
+BUILD_TYPE="debug"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso:g: --long help,clean,release,static,address_sanitizer,outdir:,gpu_list: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                MAKEARG="$MAKEARG BUILD_TYPE=rel"; BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-g | --gpu_list)
+                GPU_LIST="$2" ; shift 2;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+
+clean_rocminfo() {
+    echo "Removing rocminfo"
+    rm -rf $ROCMINFO_DEST/rocminfo
+    rm -rf $ROCMINFO_BUILD_DIR
+    rm -rf $ROCMINFO_PACKAGE_DEB
+    rm -rf $ROCMINFO_PACKAGE_RPM
+}
+
+build_rocminfo() {
+    if [ ! -d "$ROCMINFO_BUILD_DIR" ]; then
+        mkdir -p $ROCMINFO_BUILD_DIR
+        pushd $ROCMINFO_BUILD_DIR
+
+        cmake \
+            $(rocm_cmake_params) \
+            -DROCRTST_BLD_TYPE="$BUILD_TYPE" \
+	    $(rocm_common_cmake_params) \
+            -DCPACK_PACKAGE_VERSION_MAJOR="1" \
+            -DCPACK_PACKAGE_VERSION_MINOR="$ROCM_LIBPATCH_VERSION" \
+            -DCPACK_PACKAGE_VERSION_PATCH="0" \
+            -DCMAKE_SKIP_BUILD_RPATH=TRUE\
+            $ROCMINFO_SRC_ROOT
+
+        echo "Making rocminfo:"
+        cmake --build . -- $MAKEARG
+        cmake --build . -- $MAKEARG install
+        cmake --build . -- $MAKEARG package
+        popd
+    fi
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$ROCMINFO_PACKAGE_DEB" $ROCMINFO_BUILD_DIR/*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$ROCMINFO_PACKAGE_RPM" $ROCMINFO_BUILD_DIR/*.rpm
+}
+
+print_output_directory() {
+     case ${PKGTYPE} in
+         ("deb")
+             echo ${ROCMINFO_PACKAGE_DEB};;
+         ("rpm")
+             echo ${ROCMINFO_PACKAGE_RPM};;
+         (*)
+             echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+     esac
+     exit
+}
+
+case $TARGET in
+    (clean) clean_rocminfo ;;
+    (build) build_rocminfo ;;
+   (outdir) print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"
+exit 0

tools/rocm-build/build_rocmvalidationsuite.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src ROCmValidationSuite
+
+ROCM_RVS_LIB_RPATH="\$ORIGIN/.."
+
+build_rocmvalidationsuite() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    cd "${COMPONENT_SRC}"
+    mkdir -p "$BUILD_DIR"
+
+    cmake \
+        $(rocm_common_cmake_params) \
+        -DFETCH_ROCMPATH_FROM_ROCMCORE=ON \
+        -DCMAKE_SHARED_LINKER_FLAGS_INIT="-Wl,--enable-new-dtags,--rpath,$ROCM_LIB_RPATH:$ROCM_RVS_LIB_RPATH" \
+        -B "$BUILD_DIR" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p "${PACKAGE_DIR}" && cp "${BUILD_DIR}"/*."${PKGTYPE}" "${PACKAGE_DIR}"
+
+    show_build_cache_stats
+}
+
+clean_rocmvalidationsuite() {
+    echo "Cleaning ROCmValidationSuite build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "${BUILD_DIR}" "${PACKAGE_DIR}"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocmvalidationsuite ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocmvalidationsuite ;;
+    *) die "Invalid target ${TARGET}" ;;
+esac

tools/rocm-build/build_rocprim.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rocPRIM
+
+build_rocprim() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+       ASAN_CMAKE_PARAMS="false"
+    fi
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX="${ROCM_PATH}/bin/hipcc" \
+    cmake \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DBUILD_BENCHMARK=OFF \
+        -DBUILD_BENCHMARK=OFF \
+        -DBUILD_TEST=ON \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip;${ROCM_PATH}/hip/cmake" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocprim() {
+    echo "Cleaning rocPRIM build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocprim ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocprim ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocprofiler-register.sh

@@ -0,0 +1,139 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: ${BASH_SOURCE##*/} [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+API_NAME="rocprofiler-register"
+PROJ_NAME="$API_NAME"
+LIB_NAME="lib${API_NAME}"
+TARGET="build"
+MAKETARGET="deb"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_LIB="$(getLibPath)"
+PACKAGE_INCLUDE="$(getIncludePath)"
+BUILD_DIR="$(getBuildPath $API_NAME)"
+PACKAGE_DEB="$(getPackageRoot)/deb/$API_NAME"
+PACKAGE_RPM="$(getPackageRoot)/rpm/$API_NAME"
+PACKAGE_PREFIX="$ROCM_INSTALL_PATH"
+BUILD_TYPE="Debug"
+MAKE_OPTS="$DASH_JAY -C $BUILD_DIR"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="Release" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+
+    rm -rf "$BUILD_DIR"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "$PACKAGE_ROOT/${PROJ_NAME}"
+    rm -rf "$PACKAGE_LIB/${LIB_NAME}"*
+}
+
+build() {
+    echo "Building $PROJ_NAME"
+
+    if [ ! -d "$BUILD_DIR" ]; then
+        mkdir -p "$BUILD_DIR"
+        pushd "$BUILD_DIR"
+        print_lib_type $SHARED_LIBS
+        cmake \
+            $(rocm_cmake_params) \
+            $(rocm_common_cmake_params) \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            -DENABLE_LDCONFIG=OFF \
+            -DROCPROFILER_REGISTER_BUILD_CI=1 \
+            -DROCPROFILER_REGISTER_BUILD_TESTS=1 \
+            -DROCPROFILER_REGISTER_BUILD_SAMPLES=1 \
+            "$ROCPROFILER_REGISTER_ROOT"
+        popd
+    fi
+    make $MAKE_OPTS
+    make $MAKE_OPTS install
+    make $MAKE_OPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" "$BUILD_DIR/${API_NAME}"*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" "$BUILD_DIR/${API_NAME}"*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case "$TARGET" in
+    (clean) clean ;;
+    (build) build ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocprofiler.sh

@@ -0,0 +1,179 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: ${BASH_SOURCE##*/} [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+API_NAME="rocprofiler"
+PROJ_NAME="$API_NAME"
+LIB_NAME="lib${API_NAME}"
+TARGET="build"
+MAKETARGET="deb"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_LIB="$(getLibPath)"
+PACKAGE_INCLUDE="$(getIncludePath)"
+BUILD_DIR="$(getBuildPath $API_NAME)"
+PACKAGE_DEB="$(getPackageRoot)/deb/$API_NAME"
+PACKAGE_RPM="$(getPackageRoot)/rpm/$API_NAME"
+PACKAGE_PREFIX="$ROCM_INSTALL_PATH"
+BUILD_TYPE="Debug"
+MAKE_OPTS="$DASH_JAY -C $BUILD_DIR"
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0
+MAKETARGET="deb"
+PKGTYPE="deb"
+GPU_LIST="gfx900,gfx906,gfx908,gfx90a,gfx940,gfx941,gfx942,gfx1030,gfx1100,gfx1101,gfx1102"
+
+VALID_STR=$(getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@")
+eval set -- "$VALID_STR"
+
+while true; do
+    case "$1" in
+    -h | --help)
+        printUsage
+        exit 0
+        ;;
+    -c | --clean)
+        TARGET="clean"
+        ((CLEAN_OR_OUT |= 1))
+        shift
+        ;;
+    -r | --release)
+        BUILD_TYPE="RelWithDebInfo"
+        shift
+        ;;
+    -a | --address_sanitizer)
+        set_asan_env_vars
+        set_address_sanitizer_on
+        shift
+        ;;
+    -s | --static)
+        SHARED_LIBS="OFF"
+        shift
+        ;;
+    -o | --outdir)
+        TARGET="outdir"
+        PKGTYPE=$2
+        OUT_DIR_SPECIFIED=1
+        ((CLEAN_OR_OUT |= 2))
+        shift 2
+        ;;
+    -p | --package)
+        MAKETARGET="$2"
+        shift 2
+        ;;
+    --)
+        shift
+        break
+        ;;
+    *)
+        echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] " >&2
+        exit 20
+        ;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+    print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+    exit $RET_CONFLICT
+fi
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+    rm -rf "$BUILD_DIR"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "$PACKAGE_ROOT/${PROJ_NAME}"
+    rm -rf "$PACKAGE_ROOT/libexec/${PROJ_NAME}"
+    rm -rf "$PACKAGE_INCLUDE/${PROJ_NAME}"
+    rm -rf "$PACKAGE_LIB/${LIB_NAME}"*
+    rm -rf "$PACKAGE_LIB/${PROJ_NAME}"
+}
+
+build_rocprofiler() {
+    echo "Building $PROJ_NAME"
+
+    sed -i 's/set(CPACK_GENERATOR "DEB" "RPM" "TGZ")/set(CPACK_GENERATOR "DEB" "TGZ")/' "${ROCPROFILER_ROOT}/CMakeLists.txt"
+
+    PACKAGE_CMAKE="$(getCmakePath)"
+    if [ ! -d "$BUILD_DIR" ]; then
+        mkdir -p "$BUILD_DIR"
+        pushd "$BUILD_DIR"
+        print_lib_type $SHARED_LIBS
+
+        cmake \
+            $(rocm_cmake_params) \
+            -DCMAKE_MODULE_PATH="$ROCPROFILER_ROOT/cmake_modules;$PACKAGE_CMAKE/hip" \
+            $(rocm_common_cmake_params) \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            -DENABLE_LDCONFIG=OFF \
+            -DUSE_PROF_API=1 \
+            -DGPU_TARGETS="$GPU_LIST" \
+            -DPROF_API_HEADER_PATH="$WORK_ROOT/roctracer/inc/ext" \
+            -DHIP_HIPCC_FLAGS=$HIP_HIPCC_FLAGS";--offload-arch=$GPU_LIST" \
+            -DCPACK_OBJCOPY_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-objcopy" \
+            -DCPACK_READELF_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-readelf" \
+            -DCPACK_STRIP_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-strip" \
+            -DCPACK_OBJDUMP_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-objdump" \
+            "$ROCPROFILER_ROOT"
+
+        popd
+    fi
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS mytest
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS install
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" "$BUILD_DIR/${API_NAME}"*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" "$BUILD_DIR/${API_NAME}"*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+    "deb")
+        echo ${PACKAGE_DEB}
+        ;;
+    "rpm")
+        echo ${PACKAGE_RPM}
+        ;;
+    *)
+        echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2
+        exit 1
+        ;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case "$TARGET" in
+clean) clean ;;
+build) build_rocprofiler ;;
+outdir) print_output_directory ;;
+*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocr_debug_agent.sh

@@ -0,0 +1,153 @@
+#!/bin/bash
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -s,  --static           Supports static CI by accepting this param & not bailing out. No effect of the param though"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -h,  --help             Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+API_NAME=rocm-debug-agent
+PROJ_NAME=$API_NAME
+LIB_NAME=lib${API_NAME}.so
+TARGET=build
+MAKETARGET=deb
+PACKAGE_ROOT=$(getPackageRoot)
+PACKAGE_BIN="$(getBinPath)"
+PACKAGE_LIB=$(getLibPath)
+PACKAGE_INCLUDE=$(getIncludePath)
+BUILD_DIR=$(getBuildPath $API_NAME)
+PACKAGE_DEB=$(getPackageRoot)/deb/$API_NAME
+PACKAGE_RPM=$(getPackageRoot)/rpm/$API_NAME
+PACKAGE_PREFIX=$ROCM_INSTALL_PATH
+BUILD_TYPE=Debug
+MAKE_OPTS="$DASH_JAY -C"
+
+TEST_PACKAGE_DIR="$(getBinPath)/rocm-debug-agent-test"
+PACKAGE_UTILS=$(getUtilsPath)
+
+BC_DIR="$PACKAGE_ROOT/lib/bitcode"
+if [ -d "$BC_DIR" ] ; then
+  export DEVICE_LIB_PATH=$BC_DIR
+fi
+
+
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0;
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,static,address_sanitizer,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+        (-s | --static)
+                SHARED_LIBS="OFF" ; shift ;;
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+   print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+   exit $RET_CONFLICT
+fi
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+    rm -rf $BUILD_DIR
+    rm -rf $TEST_PACKAGE_DIR
+    rm -rf $PACKAGE_DEB
+    rm -rf $PACKAGE_RPM
+    rm -rf $PACKAGE_ROOT/${PROJ_NAME}
+    rm -rf $PACKAGE_LIB/${LIB_NAME}*
+    rm -f $PACKAGE_UTILS/run_rocr_debug_agent_test.sh
+}
+
+build() {
+    echo "Building $PROJ_NAME"
+
+    PACKAGE_CMAKE="$(getCmakePath)"
+    export HIPCC_COMPILE_FLAGS_APPEND="--rocm-path=$ROCM_PATH"
+    if [ ! -d "$BUILD_DIR" ]; then
+        mkdir -p "$BUILD_DIR"
+        pushd "$BUILD_DIR"
+
+        cmake $(rocm_cmake_params) \
+            -DCMAKE_PREFIX_PATH="$PACKAGE_CMAKE/amd-dbgapi" \
+            -DCMAKE_MODULE_PATH="$PACKAGE_CMAKE/hip" \
+            $(rocm_common_cmake_params) \
+            -DCMAKE_HIP_ARCHITECTURES=OFF \
+            $ROCR_DEBUG_AGENT_ROOT
+
+        popd
+    fi
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS $BUILD_DIR
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS $BUILD_DIR install
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS $BUILD_DIR package
+
+    mkdir -p $PACKAGE_LIB
+    cp -R $BUILD_DIR/${LIB_NAME}* $PACKAGE_LIB
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "${PACKAGE_DEB}" "$BUILD_DIR/${API_NAME}"*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "${PACKAGE_RPM}" "$BUILD_DIR/${API_NAME}"*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${PACKAGE_DEB};;
+        ("rpm")
+            echo ${PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean ;;
+    (build) build ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $target" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocrand.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rocRAND
+
+build_rocrand() {
+    echo "Start build"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+    fi
+
+    cd $COMPONENT_SRC && mkdir "$BUILD_DIR"
+
+    remote_name=$(git remote show | head -n 1)
+    [ "$remote_name" == "origin" ] || git remote rename "$remote_name" origin
+    git submodule update --init --force
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX=$(set_build_variables CXX)\
+    cmake \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DBUILD_TEST=ON \
+        -DBUILD_BENCHMARK=ON \
+        -DBUILD_CRUSH_TEST=ON \
+        -DDEPENDENCIES_FORCE_DOWNLOAD=OFF \
+        -DHIP_COMPILER=clang \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip" \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        -B "${BUILD_DIR}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/  && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocrand() {
+    echo "Cleaning rocRAND build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocrand ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocrand ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocsolver.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rocSOLVER
+
+build_rocsolver() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       rebuild_lapack
+    fi
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX="${ROCM_PATH}/bin/hipcc" \
+    cmake \
+        -DCPACK_SET_DESTDIR=OFF \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -Drocblas_DIR="${ROCM_PATH}/rocblas/lib/cmake/rocblas" \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DBUILD_TESTING=ON \
+        -DBUILD_CLIENTS_EXTRA_TESTS=ON \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocsolver() {
+    echo "Cleaning rocSOLVER build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocsolver ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocsolver ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocsparse.sh

@@ -0,0 +1,68 @@
+
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+PATH=${ROCM_PATH}/bin:$PATH
+set_component_src rocSPARSE
+
+build_rocsparse() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+       set_asan_env_vars
+       set_address_sanitizer_on
+    fi
+
+    MIRROR="http://compute-artifactory.amd.com/artifactory/list/rocm-generic-local/mathlib/sparse/"
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    ROCSPARSE_TEST_MIRROR=$MIRROR \
+    CXX=$(set_build_variables CXX)\
+    CC=$(set_build_variables CC)\
+    cmake \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DBUILD_CLIENTS_SAMPLES=ON \
+        -DBUILD_CLIENTS_TESTS=ON \
+        -DBUILD_CLIENTS_BENCHMARKS=ON \
+        -DCPACK_SET_DESTDIR=OFF \
+        -DCMAKE_INSTALL_PREFIX=${ROCM_PATH} \
+        -DBUILD_ADDRESS_SANITIZER="${ADDRESS_SANITIZER}" \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip;${ROCM_PATH}/hip/cmake" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+    show_build_cache_stats
+}
+
+clean_rocsparse() {
+    echo "Cleaning rocSPARSE build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocsparse ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocsparse ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rocthrust.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+set -ex
+
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+ENABLE_ADDRESS_SANITIZER=false
+build_release=true
+set_component_src rocThrust
+
+build_rocthrust() {
+    echo "Start build"
+
+    cd $COMPONENT_SRC
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+         ASAN_CMAKE_PARAMS="false"
+    fi
+
+    mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101"
+    fi
+
+    CXX=$(set_build_variables CXX)\
+    cmake \
+        ${LAUNCHER_FLAGS} \
+        $(rocm_common_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DCMAKE_MODULE_PATH="${ROCM_PATH}/lib/cmake/hip;${ROCM_PATH}/hip/cmake" \
+        -DROCPRIM_ROOT="${ROCM_PATH}/rocprim" \
+        -DBUILD_TEST=ON \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+
+
+    show_build_cache_stats
+}
+
+clean_rocthrust() {
+    echo "Cleaning rocThrust build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    (clean) clean_rocthrust ;;
+    (build) build_rocthrust ;;
+   (outdir) print_output_directory ;;
+        (*) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_roctracer.sh

@@ -0,0 +1,180 @@
+#!/bin/bash
+source "$(dirname $BASH_SOURCE)/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: ${BASH_SOURCE##*/} [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of
+    type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo "  -s,  --static             Build static lib (.a).  build instead of dynamic/shared(.so) "
+    echo
+
+    return 0
+}
+
+API_NAME="roctracer"
+PROJ_NAME="$API_NAME"
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_INCLUDE="$(getIncludePath)"
+BUILD_DIR="$(getBuildPath $API_NAME)"
+PACKAGE_DEB="$(getPackageRoot)/deb/$API_NAME"
+PACKAGE_RPM="$(getPackageRoot)/rpm/$API_NAME"
+PACKAGE_PREFIX="$ROCM_INSTALL_PATH"
+
+export HIP_PATH="${ROCM_INSTALL_PATH}"
+export HCC_HOME="${PACKAGE_ROOT}/hcc"
+
+TARGET="build"
+BUILD_TYPE="Debug"
+MAKE_OPTS="$DASH_JAY -C $BUILD_DIR"
+HIP_VDI=1
+SHARED_LIBS="ON"
+CLEAN_OR_OUT=0
+MAKETARGET="deb"
+PKGTYPE="deb"
+
+GPU_LIST="gfx900;gfx906;gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101;gfx1102"
+
+VALID_STR=$(getopt -o hcraso: --long help,clean,release,static,address_sanitizer,outdir: -- "$@")
+eval set -- "$VALID_STR"
+
+while true; do
+    case "$1" in
+    -h | --help)
+        printUsage
+        exit 0
+        ;;
+    -c | --clean)
+        TARGET="clean"
+        ((CLEAN_OR_OUT |= 1))
+        shift
+        ;;
+    -r | --release)
+        BUILD_TYPE="RelWithDebInfo"
+        shift
+        ;;
+    -a | --address_sanitizer)
+        set_asan_env_vars
+        set_address_sanitizer_on
+        shift
+        ;;
+    -s | --static)
+        SHARED_LIBS="OFF"
+        shift
+        ;;
+    -o | --outdir)
+        TARGET="outdir"
+        PKGTYPE=$2
+        OUT_DIR_SPECIFIED=1
+        ((CLEAN_OR_OUT |= 2))
+        shift 2
+        ;;
+    --)
+        shift
+        break
+        ;;
+    *)
+        echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] " >&2
+        exit 20
+        ;;
+    esac
+
+done
+
+RET_CONFLICT=1
+check_conflicting_options $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+if [ $RET_CONFLICT -ge 30 ]; then
+    print_vars $API_NAME $TARGET $BUILD_TYPE $SHARED_LIBS $CLEAN_OR_OUT $PKGTYPE $MAKETARGET
+    exit $RET_CONFLICT
+fi
+
+clean() {
+    echo "Cleaning $PROJ_NAME"
+    rm -rf "$BUILD_DIR"
+    rm -rf "$PACKAGE_DEB"
+    rm -rf "$PACKAGE_RPM"
+    rm -rf "$PACKAGE_INCLUDE/${PROJ_NAME}"
+    rm -rf "$PACKAGE_ROOT/${PROJ_NAME}"
+}
+
+copy_libs_to_workspace() {
+    if [ "$ASAN_CMAKE_PARAMS" != "true" ]; then
+        cp -R "${ROCM_INSTALL_PATH}/lib/roctracer/" "${OUT_DIR}/lib/roctracer/"
+    fi
+}
+
+build() {
+    echo "Building $PROJ_NAME"
+    PACKAGE_CMAKE="$(getCmakePath)"
+    export ROCM_PATH="${ROCM_INSTALL_PATH}"
+    export HIPCC_COMPILE_FLAGS_APPEND="--rocm-path=$ROCM_PATH"
+
+    if [ ! -d "$BUILD_DIR" ]; then
+        mkdir -p "$BUILD_DIR"
+        pushd "$BUILD_DIR"
+        print_lib_type $SHARED_LIBS
+        export HIPCC_COMPILE_FLAGS_APPEND="--rocm-path=$ROCM_PATH --offload-arch=gfx900 --offload-arch=gfx906  --offload-arch=gfx908 \
+                                                                  --offload-arch=gfx90a --offload-arch=gfx940  --offload-arch=gfx1030  \
+                                                                  --offload-arch=gfx1100 --offload-arch=gfx1101 --offload-arch=gfx1102"
+
+        cmake $(rocm_cmake_params) \
+            -DCPACK_PACKAGING_INSTALL_PREFIX="$PACKAGE_PREFIX/$PROJ_NAME" \
+            -DCMAKE_MODULE_PATH="$PACKAGE_CMAKE/hip" \
+            -DCMAKE_HIP_ARCHITECTURES=OFF \
+            -DBUILD_SHARED_LIBS=$SHARED_LIBS \
+            $(rocm_common_cmake_params) \
+            -DCMAKE_HIP_ARCHITECTURES=OFF \
+            -DENABLE_LDCONFIG=OFF \
+            -DROCM_ROOT_DIR="$ROCM_INSTALL_PATH" \
+            -DHIP_VDI="$HIP_VDI" \
+            -DROCM_RPATH="$ROCM_RPATH" \
+            -DGPU_TARGETS="$GPU_LIST" \
+            -DCPACK_OBJCOPY_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-objcopy" \
+            -DCPACK_READELF_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-readelf" \
+            -DCPACK_STRIP_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-strip" \
+            -DCPACK_OBJDUMP_EXECUTABLE="${ROCM_INSTALL_PATH}/llvm/bin/llvm-objdump" \
+            "$ROCTRACER_ROOT"
+
+        popd
+    fi
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS mytest
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS doc
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS install
+    cmake --build "$BUILD_DIR" -- $MAKE_OPTS package
+
+    copy_if DEB "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_DEB" "$BUILD_DIR/${API_NAME}"*.deb
+    copy_if RPM "${CPACKGEN:-"DEB;RPM"}" "$PACKAGE_RPM" "$BUILD_DIR/${API_NAME}"*.rpm
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+    "deb")
+        echo ${PACKAGE_DEB}
+        ;;
+    "rpm")
+        echo ${PACKAGE_RPM}
+        ;;
+    *)
+        echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2
+        exit 1
+        ;;
+    esac
+    exit
+}
+verifyEnvSetup
+
+case $TARGET in
+clean) clean ;;
+build) build && copy_libs_to_workspace ;;
+outdir) print_output_directory ;;
+*) die "$BASH_SOURCE Invalid target $TARGET - exiting" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/build_rocwmma.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rocWMMA
+
+build_rocwmma() {
+    echo "Start build"
+
+    if [ ! -e $COMPONENT_SRC/CMakeLists.txt ]; then
+        echo "Skipping rocWMMA as source is not available"
+        mkdir -p $COMPONENT_SRC
+        exit 0
+    fi
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+         set_asan_env_vars
+         set_address_sanitizer_on
+         ASAN_CMAKE_PARAMS="false"
+    fi
+    mkdir -p $BUILD_DIR && cd $BUILD_DIR
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx940;gfx941;gfx942;gfx1100;gfx1101"
+    fi
+
+    CXX=$(set_build_variables CXX)\
+    cmake \
+        $(rocm_common_cmake_params) \
+        ${LAUNCHER_FLAGS} \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DROCWMMA_BUILD_VALIDATION_TESTS=ON \
+        -DROCWMMA_VALIDATE_WITH_ROCBLAS=ON \
+        -DROCWMMA_BUILD_BENCHMARK_TESTS=ON \
+        -DROCWMMA_BENCHMARK_WITH_ROCBLAS=ON \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cmake --build "$BUILD_DIR" -- package
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR && cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+    show_build_cache_stats
+}
+
+clean_rocwmma() {
+    echo "Cleaning rocWMMA build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rocwmma ;;
+    outdir) print_output_directory ;;
+    clean) clean_rocwmma ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_rpp.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+
+set -ex
+source "$(dirname "${BASH_SOURCE[0]}")/compute_helper.sh"
+
+set_component_src rpp
+DEPS_DIR="$RPP_DEPS_LOCATION"
+
+LLVM_LIBDIR="${ROCM_PATH}/llvm/lib"
+ROCM_LLVM_LIB_RPATH="\$ORIGIN/llvm/lib"
+
+rpp_specific_cmake_params() {
+    local rpp_cmake_params
+    if [ "${ASAN_CMAKE_PARAMS}" == "true" ] ; then
+        rpp_cmake_params="-DCMAKE_EXE_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_EXE_RPATH:$LLVM_LIBDIR"
+    else
+        rpp_cmake_params=""
+    fi
+    printf '%s ' "${rpp_cmake_params}"
+}
+
+build_rpp() {
+    echo "Start build"
+
+    if [ ! -e $COMPONENT_SRC/CMakeLists.txt ]; then
+        echo "Skipping RPP build as source is not available"
+        mkdir -p $COMPONENT_SRC
+        exit 0
+    fi
+
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ]; then
+        set_asan_env_vars
+        set_address_sanitizer_on
+    fi
+
+    mkdir -p $BUILD_DIR && cd $BUILD_DIR
+
+    if [ -n "$GPU_ARCHS" ]; then
+        GPU_TARGETS="$GPU_ARCHS"
+    else
+        GPU_TARGETS="gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100"
+    fi
+
+    cmake \
+        $(rocm_common_cmake_params) \
+        ${LAUNCHER_FLAGS} \
+        -DBACKEND=HIP \
+        -DCMAKE_INSTALL_LIBDIR=$(getInstallLibDir) \
+        $(rpp_specific_cmake_params) \
+        -DAMDGPU_TARGETS=${GPU_TARGETS} \
+        -DCMAKE_SHARED_LINKER_FLAGS_INIT="-fno-openmp-implicit-rpath -Wl,--enable-new-dtags,--rpath,${ROCM_LIB_RPATH}:${DEPS_DIR}/lib:${ROCM_LLVM_LIB_RPATH}" \
+        -DCMAKE_PREFIX_PATH="${DEPS_DIR};${ROCM_PATH}" \
+        "$COMPONENT_SRC"
+
+    cmake --build "$BUILD_DIR" -- -j${PROC}
+    cmake --build "$BUILD_DIR" -- install
+    cpack -G ${PKGTYPE^^}
+
+    rm -rf _CPack_Packages/ && find -name '*.o' -delete
+    mkdir -p $PACKAGE_DIR
+    cp ${BUILD_DIR}/*.${PKGTYPE} $PACKAGE_DIR
+    show_build_cache_stats
+}
+
+clean_rpp() {
+    echo "Cleaning rpp build directory: ${BUILD_DIR} ${PACKAGE_DIR}"
+    rm -rf "$BUILD_DIR" "$PACKAGE_DIR"
+    echo "Done!"
+}
+
+stage2_command_args "$@"
+
+case $TARGET in
+    build) build_rpp ;;
+    outdir) print_output_directory ;;
+    clean) clean_rpp ;;
+    *) die "Invalid target $TARGET" ;;
+esac

tools/rocm-build/build_thunk.sh

@@ -0,0 +1,205 @@
+#!/bin/bash
+
+source "$(dirname "${BASH_SOURCE}")/compute_utils.sh"
+
+printUsage() {
+    echo
+    echo "Usage: $(basename "${BASH_SOURCE}") [options ...]"
+    echo
+    echo "Options:"
+    echo "  -c,  --clean              Clean output and delete all intermediate work"
+    echo "  -p,  --package <type>     Specify packaging format"
+    echo "  -r,  --release            Make a release build instead of a debug build"
+    echo "  -a,  --address_sanitizer  Enable address sanitizer"
+    echo "  -o,  --outdir <pkg_type>  Print path of output directory containing packages of type referred to by pkg_type"
+    echo "  -h,  --help               Prints this help"
+    echo
+    echo "Possible values for <type>:"
+    echo "  deb -> Debian format (default)"
+    echo "  rpm -> RPM format"
+    echo
+
+    return 0
+}
+
+PACKAGE_ROOT="$(getPackageRoot)"
+PACKAGE_DEB="$(getPackageRoot)/deb/libhsakmt"
+PACKAGE_RPM="$(getPackageRoot)/rpm/libhsakmt"
+THUNK_BUILD_DIR="$(getBuildPath thunk)"
+TARGET="build"
+MAKETARGET="deb"
+MAKEARG="$DASH_JAY O=$THUNK_BUILD_DIR"
+PACKAGE_LIB="$(getLibPath)"
+PACKAGE_INCLUDE="$(getIncludePath)"
+
+ROCT_BUILD_DIR="$(getBuildPath roct)"
+ROCT_PACKAGE_DEB="$(getPackageRoot)/deb/roct"
+ROCT_PACKAGE_RPM="$(getPackageRoot)/rpm/roct"
+ROCT_BUILD_TYPE="debug"
+BUILD_TYPE="Debug"
+ROCT_MAKE_OPTS="$DASH_JAY -C $ROCT_BUILD_DIR"
+CLEAN_OR_OUT=0;
+
+print_vars() {
+echo " Var status thunk "
+echo "TARGET= $TARGET"
+echo "BUILD_TYPE = $BUILD_TYPE"
+echo "MAKETARGE = $MAKETARGET"
+echo "CLEAN_OR_OUT = $CLEAN_OR_OUT"
+echo "PKGTYPE= $PKGTYPE"
+}
+
+check_conflicting_options() {
+
+    if [ "$MAKETARGET" != "deb" ] && [ "$MAKETARGET" != "rpm" ] && [ "$MAKETARGET" != "tar" ]; then
+       echo " Wrong Param Passed for Package Type.  Aborting .. "
+       print_vars
+       exit 30
+    fi
+
+    if [ $CLEAN_OR_OUT -ge 2 ]; then
+       if [ "$PKGTYPE" != "deb" ] && [ "$PKGTYPE" != "rpm" ] && [ "$PKGTYPE" != "tar" ]; then
+          echo " Wrong Param Passed for Package Type for the Outdir.  Aborting .. "
+          print_vars
+          exit 40
+       fi
+    fi
+
+    if [ $CLEAN_OR_OUT -ge 3 ]; then
+       echo " Clean & Out Both are sepcified.  Not accepted. Bailing .. "
+       exit 50
+    fi
+}
+
+VALID_STR=`getopt -o hcraso:p: --long help,clean,release,address_sanitizer,clean,outdir:,package: -- "$@"`
+eval set -- "$VALID_STR"
+
+while true ;
+do
+    case "$1" in
+        (-h | --help)
+                printUsage ; exit 0;;
+        (-c | --clean)
+                TARGET="clean" ; ((CLEAN_OR_OUT|=1)) ; shift ;;
+        (-r | --release)
+                BUILD_TYPE="RelWithDebInfo" ; shift ;;
+        (-a | --address_sanitizer)
+                set_asan_env_vars
+                set_address_sanitizer_on ; shift ;;
+	(-s)
+	       	shift ;; # Static build requested, NO-OP for this package. Required for static Jenkins builds
+        (-o | --outdir)
+                TARGET="outdir"; PKGTYPE=$2 ; OUT_DIR_SPECIFIED=1 ; ((CLEAN_OR_OUT|=2)) ; shift 2 ;;
+        (-p | --package)
+                MAKETARGET="$2" ; shift 2;;
+        --)     shift; break;;
+        (*)
+                echo " This should never come but just incase : UNEXPECTED ERROR Parm : [$1] ">&2 ; exit 20;;
+    esac
+
+done
+
+check_conflicting_options
+
+
+clean_roct() {
+    rm -rf "$ROCT_BUILD_DIR"
+    rm -rf "$ROCT_PACKAGE_DEB"
+    rm -rf "$ROCT_PACKAGE_RPM"
+    rm -rf "$PACKAGE_ROOT/libhsakmt"
+    rm -rf "$PACKAGE_INCLUDE/libhsakmt"
+    rm -f $PACKAGE_LIB/libhsakmt.so*
+    rm -f $PACKAGE_LIB/libhsakmt.a
+    rm -f $PACKAGE_INCLUDE/hsakmt*.h $PACKAGE_INCLUDE/linux/kfd_ioctl.h
+}
+
+build_roct() {
+    echo "Building ROCt"
+
+    rm -f $ROCT_BUILD_DIR/hsakmt-roct*.deb
+    rm -f $ROCT_BUILD_DIR/hsakmt-roct-dev/hsakmt-roct*.deb
+    rm -f "$ROCT_PACKAGE_DEB"/*
+
+    rm -f $ROCT_BUILD_DIR/hsakmt-roct*.rpm
+    rm -f $ROCT_BUILD_DIR/hsakmt-roct-dev/hsakmt-roct*.rpm
+    rm -f "$ROCT_PACKAGE_RPM"/*
+
+    if [ "${DISTRO_ID}" = "centos-7" ]; then
+        libdrm_cmake_var="-DHSAKMT_REQUIRES_LIBDRM=true"
+    fi
+
+    if [ ! -d "$ROCT_BUILD_DIR" ]; then
+        mkdir -p "$ROCT_BUILD_DIR"
+        pushd "$ROCT_BUILD_DIR"
+
+        cmake \
+            -DCMAKE_MODULE_PATH="$THUNK_ROOT/cmake_modules" \
+            -DBUILD_SHARED_LIBS="OFF" \
+	        $(rocm_cmake_params) \
+	    $(rocm_common_cmake_params) \
+            -DHSAKMT_INSTALL_PREFIX="$PACKAGE_ROOT" \
+            -DHSAKMT_INSTALL_LIBDIR="$PACKAGE_LIB" \
+            -DHSAKMT_PACKAGING_INSTALL_PREFIX="$ROCM_PATH" \
+            -DENABLE_LDCONFIG=OFF \
+            -DHSAKMT_WERROR=1 \
+            -DADDRESS_SANITIZER="$ADDRESS_SANITIZER" \
+            $libdrm_cmake_var \
+            "$THUNK_ROOT"
+        popd
+    fi
+    cmake --build "$ROCT_BUILD_DIR" -- $ROCT_MAKE_OPTS
+    cmake --build "$ROCT_BUILD_DIR" -- $ROCT_MAKE_OPTS install
+    cmake --build "$ROCT_BUILD_DIR" -- $ROCT_MAKE_OPTS package
+
+    if [ -e "$THUNK_ROOT/hsakmt-dev.txt" ]; then
+        cmake --build "$ROCT_BUILD_DIR" -- $ROCT_MAKE_OPTS install-dev
+        cmake --build "$ROCT_BUILD_DIR" -- $ROCT_MAKE_OPTS package-dev
+    fi
+
+    mkdir -p "$PACKAGE_LIB"
+    if [ -e "$ROCT_BUILD_DIR/libhsakmt.so" ]; then
+        cp -R "$ROCT_BUILD_DIR/libhsakmt.so"* "$PACKAGE_LIB"
+    fi
+    if [ -e "$ROCT_BUILD_DIR/libhsakmt.a" ]; then
+        cp -R "$ROCT_BUILD_DIR/libhsakmt.a" "$PACKAGE_LIB"
+    fi
+
+    mkdir -p "$ROCT_PACKAGE_DEB"
+    if [[ "${CPACKGEN:-"DEB;RPM"}" =~ "DEB" ]] ; then
+        cp -a $ROCT_BUILD_DIR/hsakmt*.deb "$ROCT_PACKAGE_DEB"
+        if [ -e "$THUNK_ROOT/hsakmt-dev.txt" ]; then
+            cp -a $ROCT_BUILD_DIR/hsakmt-roct-dev/hsakmt-roct*.deb "$ROCT_PACKAGE_DEB"
+        fi
+    fi
+
+    mkdir -p "$ROCT_PACKAGE_RPM"
+    if [[ "${CPACKGEN:-"DEB;RPM"}" =~ "RPM" ]] ; then
+        cp -a $ROCT_BUILD_DIR/hsakmt*.rpm "$ROCT_PACKAGE_RPM"
+        if [ -e "$THUNK_ROOT/hsakmt-dev.txt" ]; then
+            cp -a $ROCT_BUILD_DIR/hsakmt-roct-dev/hsakmt-roct*.rpm "$ROCT_PACKAGE_RPM"
+        fi
+    fi
+}
+
+print_output_directory() {
+    case ${PKGTYPE} in
+        ("deb")
+            echo ${ROCT_PACKAGE_DEB};;
+        ("rpm")
+            echo ${ROCT_PACKAGE_RPM};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+verifyEnvSetup
+
+case $TARGET in
+    (clean) clean_roct ;;
+    (build) build_roct ;;
+    (outdir) print_output_directory ;;
+    (*) die "Invalid target $TARGET" ;;
+esac
+
+echo "Operation complete"

tools/rocm-build/ccache-env-mathlib.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# set ccache environment variable for math libraries
+if [ "${CCACHE_ENABLED}" == "true" ] && [ -f "${OUT_DIR}"/logs/lightning ]; then
+    export LAUNCHER_FLAGS="-DCMAKE_CXX_COMPILER_LAUNCHER=/usr/local/bin/ccache -DCMAKE_C_COMPILER_LAUNCHER=/usr/local/bin/ccache"
+    export CCACHE_IGNOREHEADERS=${ROCM_PATH}/include:${ROCM_PATH}/llvm/include:${ROCM_PATH}/lib/llvm/lib/clang/17/include:${ROCM_PATH}/lib/llvm/include
+    export CCACHE_COMPILERCHECK=none
+    export CCACHE_EXTRAFILES=${OUT_DIR}/rocm_compilers_hash_file
+fi

tools/rocm-build/compute_helper.sh

@@ -0,0 +1,284 @@
+#!/bin/bash
+
+# compute_helper.sh is created to add common functions similar to compute_utils.sh in stg1
+# stg2 build scripts can make use of common function
+# TODO:  Component build scripts can be optimized by adding common function in this file(ex for ASAN, Debugging  etc)
+#        All build scripts should use the common function.
+
+set -e
+set -o pipefail
+# Set the LLVM directory path with respect to ROCM_PATH
+# LLVM is installed in $ROCM_PATH/lib/llvm
+ROCM_LLVMDIR="lib/llvm"
+# Set ADDRESS_SANITIZER to OFF by default
+export ADDRESS_SANITIZER="OFF"
+# Print message to stderr
+#   param message string to print on exit
+# Example: printErr "file not found"
+printErr() {
+    echo "$@" 1>&2
+}
+
+# Print message to stderr and terminate current program
+#   param message string to print on exit
+# Example: die "Your program" has terminated
+die() {
+    printErr "FATAL: $@"
+    exit 1
+}
+
+# Die if first argument is empty
+#   param string to validate
+#   param error message
+# Example: die "$VARIABLE" "Your program" has terminated
+dieIfEmpty() {
+    if [ "$1" == "" ]; then
+        shift
+        die "$@"
+    fi
+}
+
+# Copy a file or directory to target location and show single line progress
+progressCopy() {
+    if [ -d "$1" ]; then
+        rsync -a "$1"/* "$2"
+    else
+        rsync -a "$1" "$2"
+    fi
+}
+
+# Get OS identification string
+# xargs will remove the trailing whitespaces
+getOsVersion() {
+    lsb_release -d | cut -d: -f2 | xargs
+}
+
+# Get kernel identification string
+getKernelVersion() {
+    uname -r
+}
+
+# Trim excessive whitespace from a string
+strTrim() {
+    echo "$@" | xargs
+}
+
+# Return whether the booted OS is Fedora or not
+isFedora() {
+    grep -iq fedora /etc/os-release
+}
+
+# Return whether the booted system is EFI or not
+isEFI() {
+    [ -d "/sys/firmware/efi" ]
+}
+
+print_lib_type() {
+   if [ "$1" == "OFF" ];
+   then
+       echo " Building Archive "
+   else
+       echo " Building Shared Object "
+   fi
+}
+
+# Get CMAKE build flags for CMAKE build trigger
+set_build_variables() {
+    local cmake_cxx_flag_params
+    local cmake_cc_flag_params
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ] ; then
+        cmake_cxx_flag_params="$ROCM_PATH/llvm/bin/clang++"
+        cmake_cc_flag_params="$ROCM_PATH/llvm/bin/clang"
+        cmake_comp_params=(
+            "-DCMAKE_C_COMPILER=$ROCM_PATH/llvm/bin/clang"
+            "-DCMAKE_CXX_COMPILER=$ROCM_PATH/llvm/bin/clang++"
+        )
+    else
+        cmake_cxx_flag_params="$ROCM_PATH/bin/hipcc"
+        cmake_cc_flag_params="$ROCM_PATH/bin/hipcc"
+        cmake_comp_params=(
+            "-DCMAKE_C_COMPILER=$ROCM_PATH/bin/hipcc"
+            "-DCMAKE_CXX_COMPILER=$ROCM_PATH/bin/hipcc"
+        )
+    fi
+
+    case "$1" in
+    ("CXX")
+      printf "%s" "${cmake_cxx_flag_params}"
+      ;;
+     ("CC")
+      printf "%s" "${cmake_cc_flag_params}"
+      ;;
+     ("CMAKE_C_CXX")
+      printf '%s ' "${cmake_comp_params[@]}"
+      ;;
+     (*)
+      exit 1
+      ;;
+    esac
+    exit
+}
+
+# Get the directory containing the cmake config files
+getCmakePath() {
+    local rocmInstallPath=${ROCM_PATH}
+    local cmakePath="lib/cmake"
+    dieIfEmpty "$rocmInstallPath"
+    echo "$rocmInstallPath/$cmakePath"
+}
+
+# Get the install directory name for libraries
+# lib - For normal builds
+# lib/asan -For ASAN builds
+getInstallLibDir() {
+    local libDir="lib"
+    if [ "${ENABLE_ADDRESS_SANITIZER}" == "true" ] ; then
+        libDir="lib/asan"
+    fi
+    echo "$libDir"
+}
+
+# TODO: Use the function to set the LDFLAGS and CXXFLAGS for ASAN
+# rather than setting in individual build scripts
+set_asan_env_vars() {
+    # Flag to set cmake build params for ASAN builds
+    ASAN_CMAKE_PARAMS="true"
+    export ADDRESS_SANITIZER="ON"
+    LLVM_BIN_DIR="${ROCM_PATH}/llvm/bin"
+    export CC="$LLVM_BIN_DIR/clang"
+    export CXX="$LLVM_BIN_DIR/clang++"
+    export FC="$LLVM_BIN_DIR/flang"
+    export PATH="$LLVM_BIN_DIR/:$PATH"
+    # get exact path to ASAN lib containing clang version
+    ASAN_LIB_PATH=$(clang --print-file-name=libclang_rt.asan-x86_64.so)
+    export LD_LIBRARY_PATH="${ASAN_LIB_PATH%/*}${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+    export ASAN_OPTIONS="detect_leaks=0"
+}
+
+set_address_sanitizer_on() {
+    export CFLAGS="-fsanitize=address -shared-libasan -g -gz"
+    export CXXFLAGS="-fsanitize=address -shared-libasan -g -gz"
+    export LDFLAGS="-Wl,--enable-new-dtags -fuse-ld=lld  -fsanitize=address -shared-libasan -g -gz -Wl,--build-id=sha1 -L${ROCM_PATH}/lib/asan"
+}
+
+rebuild_lapack() {
+    wget -nv -O lapack-3.9.1.tar.gz \
+        http://compute-artifactory.amd.com/artifactory/rocm-generic-thirdparty-deps/ubuntu/lapack-v3.9.1.tar.gz
+    sh -c "echo 'd0085d2caf997ff39299c05d4bacb6f3d27001d25a4cc613d48c1f352b73e7e0 *lapack-3.9.1.tar.gz' | sha256sum -c"
+    tar xzf lapack-3.9.1.tar.gz --one-top-level=lapack-src --strip-components 1
+    rm lapack-3.9.1.tar.gz
+
+    cmake -Slapack-src -Blapack-bld \
+        ${LAUNCHER_FLAGS} \
+        -DBUILD_TESTING=OFF \
+        -DCBLAS=ON \
+        -DLAPACKE=OFF
+    cmake --build lapack-bld -- -j${PROC}
+    cmake --build lapack-bld -- install
+    rm -r lapack-src lapack-bld
+}
+
+# debug function #dumping values in case of error to solve the same
+print_vars() {
+echo " Status of Vars in $1 build "
+echo " TARGET= $2 "
+echo " BUILD_TYPE = $3 "
+echo " SHARED_LIBS = $4 "
+echo " CLEAN_OR_OUT = $5 "
+echo " PKGTYPE= $6 "
+echo " MAKETARGET = $7 "
+}
+
+# Common cmake parameters can be set
+# component build scripts can use this function
+rocm_common_cmake_params() {
+    local cmake_params
+    if [ "${ASAN_CMAKE_PARAMS}" == "true" ] ; then
+        local ASAN_LIBDIR="lib/asan"
+        local CMAKE_PATH=$(getCmakePath)
+        cmake_params=(
+            "-DCMAKE_PREFIX_PATH=$CMAKE_PATH;${ROCM_PATH}/$ASAN_LIBDIR;$ROCM_PATH/llvm;$ROCM_PATH"
+            "-DCMAKE_BUILD_TYPE=${BUILD_TYPE:-'RelWithDebInfo'}"
+            "-DCMAKE_SHARED_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_LIB_RPATH"
+            "-DCMAKE_EXE_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--rpath,$ROCM_ASAN_EXE_RPATH"
+            "-DENABLE_ASAN_PACKAGING=true"
+        )
+    else
+        cmake_params=(
+            "-DCMAKE_PREFIX_PATH=${ROCM_PATH}/llvm;${ROCM_PATH}"
+            "-DCMAKE_BUILD_TYPE=${BUILD_TYPE:-'Release'}"
+            "-DCMAKE_SHARED_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--rpath,$ROCM_LIB_RPATH"
+            "-DCMAKE_EXE_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--rpath,$ROCM_EXE_RPATH"
+        )
+    fi
+    printf '%s ' "${cmake_params[@]}"
+
+    local common_cmake_params
+        common_cmake_params=(
+            "-DCMAKE_VERBOSE_MAKEFILE=1"
+            "-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=FALSE"
+            "-DCMAKE_INSTALL_PREFIX=${ROCM_PATH}"
+            "-DCMAKE_PACKAGING_INSTALL_PREFIX=${ROCM_PATH}"
+            "-DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF"
+            "-DROCM_SYMLINK_LIBS=OFF"
+            "-DCPACK_PACKAGING_INSTALL_PREFIX=${ROCM_PATH}"
+            "-DROCM_DISABLE_LDCONFIG=ON"
+            "-DROCM_PATH=${ROCM_PATH}"
+        )
+    printf '%s ' "${common_cmake_params[@]}"
+}
+
+# Setup a number of variables to specify where to find the source
+# where to do the build and where to put the packages
+# Note the PACKAGE_DIR downcases the package name
+# This could be extended to do different things based on $1
+set_component_src(){
+    COMPONENT_SRC="$LIBS_WORK_DIR/$1"
+
+    BUILD_DIR="$OUT_DIR/build/$1"
+    DEB_PATH="$OUT_DIR/${PKGTYPE}/${1,,}"
+    RPM_PATH="$OUT_DIR/${PKGTYPE}/${1,,}"
+    PACKAGE_DIR="$OUT_DIR/${PKGTYPE}/${1,,}"
+}
+
+# Standard definition of function to print the package location.  If
+# for some reason a custom version is needed then it can overwrite
+# this definition
+# TODO: Don't use a global PKGTYPE, pass the value in as a parameter
+print_output_directory() {
+    case ${1:-$PKGTYPE} in
+        ("deb")
+            echo ${DEB_PATH};;
+        ("rpm")
+            echo ${RPM_PATH};;
+        (*)
+            echo "Invalid package type \"${PKGTYPE}\" provided for -o" >&2; exit 1;;
+    esac
+    exit
+}
+
+# Standard argument processing
+# Here to avoid repetition
+TARGET="build"			# default target
+stage2_command_args(){
+    while [ "$1" != "" ];
+    do
+	case $1 in
+            -o  | --outdir )
+		shift 1; PKGTYPE=$1 ; TARGET="outdir" ;;
+            -c  | --clean )
+		TARGET="clean" ;;
+            *)
+		break ;;
+	esac
+	shift 1
+    done
+}
+
+show_build_cache_stats(){
+    if [ "$CCACHE_ENABLED" = "true" ] ; then
+	if ! ccache -s ; then
+	    echo "Unable to display ccache stats"
+	fi
+    fi
+}

tools/rocm-build/compute_utils.sh

@@ -0,0 +1,372 @@
+#!/bin/bash
+
+: <<'END_COMMENT'
+    This script retains only those functions from the original compute_utils.sh
+    that the ROCm build scripts utilize.
+END_COMMENT
+
+set -e
+set -o pipefail
+
+
+# Set a sensible default value for DASH_JAY in case none is provided
+DASH_JAY=${DASH_JAY:-"-j $(nproc)"}
+
+# Enable ccache by default unless requested otherwhise
+if [[ "$ROCM_USE_CCACHE" != "0" ]] ; then
+	for d in /usr/lib/ccache /usr/lib64/ccache ;do
+		if [ -d "$d" ]; then
+			PATH="$d:$PATH"
+			break # Only add one ccache at most
+		fi
+	done
+fi
+
+# Print message to stderr
+#   param message string to print on exit
+# Example: printErr "file not found"
+printErr() {
+    echo "$@" 1>&2
+}
+
+# Print message to stderr and terminate current program
+#   param message string to print on exit
+# Example: die "Your program" has terminated
+die() {
+    printErr "FATAL: $@"
+    exit 1
+}
+
+# Die if first argument is empty
+#   param string to validate
+#   param error message
+# Example: die "$VARIABLE" "Your program" has terminated
+dieIfEmpty() {
+    if [ "$1" == "" ]; then
+        shift
+        die "$@"
+    fi
+}
+
+# Get directory with build output package
+# Precedence:
+#       1. PWD
+#       2. Caller's folder
+#       3. Known build output folder
+getPackageRoot() {
+    local scriptPath=$(readlink -f $(dirname $BASH_SOURCE))
+    local testFile="build.version"
+
+    if [ -a "$PWD/$testFile" ]; then
+        echo "$PWD"
+    elif [ -a "$scriptPath/../$testFile" ]; then
+        echo "$scriptPath/.."
+    elif [ -a "$scriptPath/$testFile" ]; then
+        echo "$scriptPath"
+    elif [ ! -z "$OUT_DIR" ]; then
+        echo "$OUT_DIR"
+    else
+        die "Failed to determine package directory"
+    fi
+}
+
+# Get a list of directories containing the build output
+# shared objects.
+# Important: PWD takes precedence over build output folder
+getLibPath() {
+    local packageRoot="$(getPackageRoot)"
+    dieIfEmpty "$packageRoot"
+    echo "$packageRoot/lib"
+}
+
+# Get a list of directories containing the output executables
+#     param binDir (optional) - package name
+# Important: PWD takes precedence over build output folder
+getBinPath() {
+    local binDir="$1"
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+
+    if [ "$binDir" == "" ]; then
+        echo "$packageRoot/bin"
+    else
+        echo "$packageRoot/bin/$binDir"
+    fi
+}
+
+# Get a list of directories containing the output source files
+# Important: PWD takes precedence over build output folder
+getSrcPath() {
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+    echo "$packageRoot/src"
+}
+
+# Get a list of directories to place build output
+#   param moduleName - name of the module for the build path
+# Important: PWD takes precedence over build output folder
+getBuildPath() {
+    local moduleName="$1"
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+    echo "$packageRoot/build/$moduleName"
+}
+
+# Get a list of directories containing the output etc files
+# Important: PWD takes precedence over build output folder
+getUtilsPath() {
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+    echo "$packageRoot/utils"
+}
+
+# Get a list of directories containing the output include files
+# Important: PWD takes precedence over build output folder
+getIncludePath() {
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+    echo "$packageRoot/include"
+}
+
+# Get the directory containing the cmake config files
+getCmakePath() {
+    local rocmInstallPath=${ROCM_INSTALL_PATH}
+    local cmakePath="lib/cmake"
+    if [ "$ASAN_CMAKE_PARAMS" == "true" ] ; then
+        cmakePath="lib/asan/cmake"
+    fi
+    dieIfEmpty "$rocmInstallPath"
+    echo "$rocmInstallPath/$cmakePath"
+}
+
+# Get a list of directories containing the output debian files
+# Important: PWD takes precedence over build output folder
+getDebPath() {
+    local packageName="$1"
+    dieIfEmpty "$packageName" "No valid package name specified"
+
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+
+    echo "$packageRoot/deb/$packageName"
+}
+
+# Get a list of directories containing the output rpm files
+# Important: PWD takes precedence over build output folder
+getRpmPath() {
+    local packageName="$1"
+    dieIfEmpty "$packageName" "No valid package name specified"
+
+    local packageRoot=$(getPackageRoot)
+    dieIfEmpty "$packageRoot"
+
+    echo "$packageRoot/rpm/$packageName"
+}
+
+
+
+verifyEnvSetup() {
+    if [ -z "$OUT_DIR" ]; then
+        die "Please source build/envsetup.sh first."
+    fi
+}
+
+# Copy a file or directory to target location and show single line progress
+progressCopy() {
+    if [ -d "$1" ]; then
+        rsync -a "$1"/* "$2"
+    else
+        rsync -a "$1" "$2"
+    fi
+}
+
+
+#following three common functions have been written to addition of static libraries
+print_lib_type() {
+   if [ "$1" == "OFF" ];
+   then
+       echo " Building Archive "
+   else
+       echo " Building Shared Object "
+   fi
+}
+
+check_conflicting_options() {
+    # 1->CLEAN_OR_OUT 2->PKGTYPE 3->MAKETARGET
+    RET_CONFLICT=0
+    if [ $1 -ge 2 ]; then
+       if [ "$2" != "deb" ] && [ "$2" != "rpm" ] && [ "$2" != "tar" ]; then
+          echo " Wrong Param Passed for Package Type for the Outdir... "
+          RET_CONFLICT=30
+       fi
+    fi
+    # check Clean Vs Outdir
+    if [ $1 -ge 3 ] && [ $RET_CONFLICT -eq 0 ] ; then
+       echo " Clean & Out Both are sepcified.  Not accepted. Bailing .. "
+       RET_CONFLICT=40
+    fi
+    if [ $RET_CONFLICT -eq 0 ] && [ "$3" != "deb" ] && [ "$3" != "rpm" ] && [ "$3" != "all" ] && [ "$3" != "tar" ]; then
+       echo " Wrong Param Passed for Package Type... "
+       RET_CONFLICT=50
+    fi
+}
+
+set_asan_env_vars() {
+    # Flag to set cmake build params for ASAN builds
+    ASAN_CMAKE_PARAMS="true"
+    # Pass the LLVM bin path as the first parameter
+    LLVM_BIN_DIR=${1:-"${ROCM_INSTALL_PATH}/llvm/bin"}
+    export CC="$LLVM_BIN_DIR/clang"
+    export CXX="$LLVM_BIN_DIR/clang++"
+    export PATH="$PATH:$LLVM_BIN_DIR/"
+    # get exact path to ASAN lib containing clang version
+    ASAN_LIB_PATH=$(clang --print-file-name=libclang_rt.asan-x86_64.so)
+    export LD_LIBRARY_PATH="${ASAN_LIB_PATH%/*}${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+    export ASAN_OPTIONS="detect_leaks=0"
+}
+
+set_address_sanitizer_on() {
+    # In SLES and RHEL debuginfo package is not getting generated
+    # when compiler is set to clang. Using default -gdwarf-5 is getting unhandled in these distros
+    # So setting -gdwarf-4 as a quick fix
+    # TODO: -gdwarf-5 unhandling when compiler set to clang need to be fixed
+    SET_DWARF_VERSION_4=""
+    if [[ $DISTRO_ID == sles* ]] || [[ $DISTRO_ID == rhel* ]]; then
+        SET_DWARF_VERSION_4="-gdwarf-4"
+    fi
+    export CFLAGS="-fsanitize=address -shared-libasan -g $SET_DWARF_VERSION_4"
+    export CXXFLAGS="-fsanitize=address -shared-libasan -g $SET_DWARF_VERSION_4"
+    export LDFLAGS="-Wl,--enable-new-dtags -fuse-ld=lld  -fsanitize=address -shared-libasan -g -Wl,--build-id=sha1 -L$ROCM_INSTALL_PATH/lib/asan"
+}
+
+ack_and_ignore_asan() {
+    echo "-a parameter accepted but ignored"
+}
+
+#debug function #dumping values in case of error to solve the same
+print_vars() {
+echo " Status of Vars in $1 build "
+echo " TARGET= $2 "
+echo " BUILD_TYPE = $3 "
+echo " SHARED_LIBS = $4 "
+echo " CLEAN_OR_OUT = $5 "
+echo " PKGTYPE= $6 "
+echo " MAKETARGET = $7 "
+}
+
+# Provide this as a function, rather than a variable to delay the evaluation
+# of variables. In particular we might want to put code in here which changes
+# depending on if we are building with the address sanitizer or not
+# Can do things like set the packaging type - no point in packaging RPM on debian and
+# vica versa.
+# Set CPACK_RPM_INSTALL_WITH_EXEC so it packages debug info for shared libraries.
+rocm_common_cmake_params(){
+    if [ "$BUILD_TYPE" = "RelWithDebInfo" ] ; then
+	printf '%s ' "-DCPACK_RPM_DEBUGINFO_PACKAGE=TRUE" \
+	       "-DCPACK_DEBIAN_DEBUGINFO_PACKAGE=TRUE" \
+	       "-DCPACK_RPM_INSTALL_WITH_EXEC=TRUE" \
+               # end of list comment or blank line
+    fi
+    printf '%s ' "-DROCM_DEP_ROCMCORE=ON" \
+                 "-DCMAKE_EXE_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--build-id=sha1,--rpath,$ROCM_EXE_RPATH" \
+                 "-DCMAKE_SHARED_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--build-id=sha1,--rpath,$ROCM_LIB_RPATH" \
+                 "-DFILE_REORG_BACKWARD_COMPATIBILITY=OFF" \
+                 "-DINCLUDE_PATH_COMPATIBILITY=OFF" \
+    # set lib directory to lib/asan for ASAN builds
+    # Disable file reorg backward compatibilty for ASAN builds
+    # ENABLE_ASAN_PACKAGING - Used for enabling ASAN packaging
+    if [ "$ASAN_CMAKE_PARAMS" == "true" ] ; then
+        local asan_common_cmake_params
+        local ASAN_LIBDIR="lib/asan"
+        local CMAKE_PATH=$(getCmakePath)
+        asan_common_cmake_params=(
+            "-DCMAKE_INSTALL_LIBDIR=$ASAN_LIBDIR"
+            "-DCMAKE_PREFIX_PATH=$CMAKE_PATH;${ROCM_INSTALL_PATH}/$ASAN_LIBDIR;$ROCM_INSTALL_PATH/llvm;$ROCM_INSTALL_PATH"
+            "-DENABLE_ASAN_PACKAGING=$ASAN_CMAKE_PARAMS"
+            "-DCMAKE_SHARED_LINKER_FLAGS_INIT=-Wl,--enable-new-dtags,--build-id=sha1,--rpath,$ROCM_ASAN_LIB_RPATH"
+        )
+        printf '%s ' "${asan_common_cmake_params[@]}"
+    else
+        printf '%s ' "-DCMAKE_INSTALL_LIBDIR=lib" \
+        # end of list comment or blank line
+    fi
+}
+
+rocm_cmake_params() {
+    local cmake_params
+
+    cmake_params=(
+        "-DCMAKE_PREFIX_PATH=${ROCM_INSTALL_PATH}/llvm;${ROCM_INSTALL_PATH}"
+        "-DCMAKE_BUILD_TYPE=${BUILD_TYPE:-'RelWithDebInfo'}"
+        "-DCMAKE_VERBOSE_MAKEFILE=1"
+        "-DCPACK_GENERATOR=${CPACKGEN:-'DEB;RPM'}"
+        "-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=FALSE"
+        "-DROCM_PATCH_VERSION=${ROCM_LIBPATCH_VERSION}"
+        "-DCMAKE_INSTALL_PREFIX=${ROCM_INSTALL_PATH}"
+        "-DCPACK_PACKAGING_INSTALL_PREFIX=${ROCM_INSTALL_PATH}"
+    )
+
+    printf '%s ' "${cmake_params[@]}"
+}
+
+copy_if(){
+    local type=$1 selector=$2 dir=$3
+    shift 3
+    mkdir -p "$dir"
+    if [[ "$selector" =~ "$type" ]] ; then
+	cp -a "$@" "$dir"
+    fi
+    # handle ddeb files as well, renaming them on the way
+    for f
+    do
+	case "$f" in
+	    # Properly formed debian package name is a number of _ separated fields
+	    # The first is the package name.
+	    # Second is version number
+	    # third is architecture
+	    # Ensure we have at least one _ in the name
+	    (*"_"*".deb")
+		local deb=${f%.deb}
+		local basename=${deb##*/}
+		local dirname=${f%/*}
+                # filename($f) can be either /some/path/pkgname.deb or pkgname.deb
+                # If its pkgname.deb, then directory should be .
+                [[ "$dirname" == "$f" ]] && dirname=.
+		local pkgname=${basename%%_*}
+		local pkgextra=${basename#*_}
+		# cmake 3.22 creates the filename by replacing .deb with -dbgsym.ddeb
+		# at least for hostcall. Mind you hostcall looks to be incorrectly packaged.
+		if [ -e "${deb}-dbgsym.ddeb" ]
+		then
+		    dest=${deb##*/}
+		    dest="${dest%%_*}-dbgsym_${dest#*_}"
+		    cp -a "${deb}-dbgsym.ddeb" "$dir/${dest##*/}.deb"
+		fi
+		# This is needed for comgr
+		if [ -e "$dirname/${pkgname}-dbgsym_${pkgextra}.ddeb" ]
+		then
+		    cp "$dirname/${pkgname}-dbgsym_${pkgextra}.ddeb" "$dir/${pkgname}-dbgsym_${pkgextra}.deb"
+		fi
+		;;
+	esac
+    done
+}
+
+
+# Function to remove -r or -R from MAKEFLAGS
+remove_make_r_flags(){
+    local firstword='^[^ ]*'
+    if [[ "$MAKEFLAGS" =~ ${firstword}r ]] ; then MAKEFLAGS=${MAKEFLAGS/r/} ; fi
+    if [[ "$MAKEFLAGS" =~ ${firstword}R ]] ; then MAKEFLAGS=${MAKEFLAGS/R/} ; fi
+}
+
+# Set a variable to the value needed by cmake to use ninja if it is available
+# If GEN_NINJA is already defined, even as the empty string, then leave the value alone
+# Intended use in build_xxxx.sh is ${GEN_NINJA:+"$GEN_NINJA"} to cope with potentially weird values
+# but in practice just ${GEN_NINJA} without quotes will be fine.
+# e.g.            cmake -DCMAKE_BUILD_TYPE="$BUILD_TYPE" $GEN_NINJA
+# If for some reason you wanted to build without ninja just export an empty GEN_NINJA variable
+if [ "${GEN_NINJA+defined}" != "defined" ] && command -v ninja >/dev/null ; then
+    GEN_NINJA=-GNinja
+fi
+

tools/rocm-build/docker/ubuntu20/Dockerfile

@@ -0,0 +1,7 @@
+FROM ubuntu:focal as builder
+COPY packages /tmp/packages
+COPY install-prerequisites.sh /tmp/install-prerequisites.sh
+ENV KBUILD_PKG_ROOTCMD=
+ENV RPP_DEPS_LOCATION=/usr/local/rpp-deps
+RUN /tmp/install-prerequisites.sh
+WORKDIR /src

tools/rocm-build/docker/ubuntu20/README.md

@@ -0,0 +1,26 @@
+## Steps to build the Docker Image
+
+1. Clone this repositry
+
+   ```bash
+   git clone -b roc-6.1.x https://github.com/ROCm/ROCm.git
+   ```
+
+2. Go into the OS specific docker directory in build-infra
+
+    ```bash
+    cd ROCm/rocm-build/docker/ubuntu20
+    ```
+
+3. Build the Docker image
+
+   ```bash
+   docker build -t <docker Image Name> .
+    ```
+
+    replace the `<docker Image Name>` with the new Docker image Name of your choice,
+4. After successful build, verify your \<docker Image Name\> in the list all available docker images.
+
+    ```bash
+    docker images
+    ```

tools/rocm-build/docker/ubuntu20/install-prerequisites.sh

@@ -0,0 +1,217 @@
+#! /usr/bin/bash
+
+set -ex
+
+
+apt-get update 
+DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true apt-get install --no-install-recommends -y $(grep -v '^#' /tmp/packages)
+apt-get clean 
+rm -rf /var/cache/apt/ /var/lib/apt/lists/* /etc/apt/apt.conf.d/01proxy
+
+#Install git 2.17.1 version
+curl -o git.tar.gz https://cdn.kernel.org/pub/software/scm/git/git-2.17.1.tar.gz 
+tar -zxf git.tar.gz
+cd git-* 
+make prefix=/usr/local all 
+make prefix=/usr/local install
+git --version
+
+#install argparse and CppHeaderParser python modules for roctracer and rocprofiler
+# CppHeader needs setuptools. setuptools needs wheel.
+pip3 install --no-cache-dir setuptools wheel tox
+pip3 install --no-cache-dir CppHeaderParser argparse requests lxml barectf recommonmark jinja2==3.0.0  websockets matplotlib numpy scipy minimal msgpack pytest sphinx joblib cmake==3.25.2 pandas myst-parser
+
+# Allow sudo for everyone user
+echo 'ALL ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/everyone
+
+# Install OCaml packages to build LLVM's OCaml bindings to be used in lightning compiler test pipeline
+wget -nv https://sourceforge.net/projects/opam.mirror/files/2.1.4/opam-2.1.4-x86_64-linux -O /usr/local/bin/opam 
+chmod +x /usr/local/bin/opam 
+opam init --yes --disable-sandboxing 
+opam install ctypes --yes
+
+# Install and modify git-repo (#!/usr/bin/env python -> #!/usr/bin/env python3)
+curl https://storage.googleapis.com/git-repo-downloads/repo > /usr/bin/repo
+chmod a+x /usr/bin/repo
+
+# Build a newer version of doxygen because of issue 6456
+#Install doxygen 1.8.11 for dbgapi
+mkdir /tmp/doxygen
+cd /tmp/doxygen
+curl -LO https://sourceforge.net/projects/doxygen/files/rel-1.8.18/doxygen-1.8.18.src.tar.gz 
+tar xzf doxygen-1.8.18.src.tar.gz 
+cd doxygen-1.8.18 
+mkdir -p build 
+cd build 
+cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local -Wno-dev .. 
+make -j install 
+cd ../.. 
+rm -rf /tmp/doxygen
+
+# Build ccache from the source
+cd /tmp 
+git clone https://github.com/ccache/ccache -b v4.7.5 
+cd ccache 
+mkdir build 
+cd build 
+cmake -DCMAKE_BUILD_TYPE=Release .. 
+make 
+make install 
+cd /tmp 
+rm -rf ccache
+
+# Install sharp from MLNX_OFED_LINUX as dependency for rccl-rdma-sharp-plugins
+cd /var/tmp
+mkdir mlnx 
+wget -O mlnx/tar.tgz https://content.mellanox.com/ofed/MLNX_OFED-5.2-1.0.4.0/MLNX_OFED_LINUX-5.2-1.0.4.0-ubuntu20.04-x86_64.tgz 
+tar -xz -C mlnx -f mlnx/tar.tgz 
+apt-key add mlnx/*/RPM-GPG-KEY-Mellanox 
+echo "deb [arch=amd64] file:$(echo $PWD/mlnx/*/DEBS) ./" > /etc/apt/sources.list.d/sharp.list 
+apt update 
+apt install -y sharp 
+apt clean 
+rm -rf /var/cache/apt/ /var/lib/apt/lists/* mlnx /etc/apt/sources.list.d/sharp.list
+
+#Install older version of hwloc-devel package for rocrtst
+curl -lO https://download.open-mpi.org/release/hwloc/v1.11/hwloc-1.11.13.tar.bz2 
+tar -xvf hwloc-1.11.13.tar.bz2 
+cd hwloc-1.11.13 
+./configure 
+make 
+make install 
+cp /usr/local/lib/libhwloc.so.5 /usr/lib 
+hwloc-info --version
+
+## Install googletest from source
+mkdir -p /tmp/gtest 
+cd /tmp/gtest 
+wget https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip -O googletest.zip 
+unzip googletest.zip 
+cd googletest-1.14.0/
+mkdir build
+cd build 
+cmake ..
+make -j$(nproc)
+make install
+rm -rf /tmp/gtest
+
+## Install gRPC from source
+## RDC Pre-requisites
+GRPC_ARCHIVE=grpc-1.61.0.tar.gz
+mkdir /tmp/grpc
+mkdir /usr/grpc
+cd /tmp 
+git clone --recurse-submodules -b v1.61.0 https://github.com/grpc/grpc 
+cd grpc
+mkdir -p cmake/build
+cd cmake/build
+cmake -DgRPC_INSTALL=ON -DBUILD_SHARED_LIBS=ON -DgRPC_BUILD_TESTS=OFF  -DCMAKE_INSTALL_PREFIX=/usr/grpc   -DCMAKE_CXX_STANDARD=14  ../.. 
+make -j$(nproc)
+make install 
+cd  / 
+rm -rf /tmp/grpc 
+
+## Download prebuilt AMD multithreaded blis (2.0)
+## Reference : https://github.com/ROCmSoftwarePlatform/rocBLAS/blob/develop/install.sh#L403
+mkdir -p /tmp/blis
+cd /tmp/blis 
+wget -O - https://github.com/amd/blis/releases/download/2.0/aocl-blis-mt-ubuntu-2.0.tar.gz | tar xfz - 
+mv amd-blis-mt /usr/blis 
+cd / 
+rm -rf /tmp/blis
+
+## Download aocl-linux-aocc-4.0_1_amd64.deb
+mkdir -p /tmp/aocl 
+cd /tmp/aocl 
+wget -nv https://download.amd.com/developer/eula/aocl/aocl-4-0/aocl-linux-aocc-4.0_1_amd64.deb 
+apt install ./aocl-linux-aocc-4.0_1_amd64.deb
+rm -rf /tmp/aocl
+
+## lapack(3.9.1v)
+## Reference https://github.com/ROCmSoftwarePlatform/rocSOLVER/blob/develop/install.sh#L174
+lapack_version=3.9.1
+lapack_srcdir=lapack-$lapack_version
+lapack_blddir=lapack-$lapack_version-bld
+mkdir -p /tmp/lapack
+cd /tmp/lapack
+mkdir -p /tmp/lapack
+cd /tmp/lapack
+rm -rf "$lapack_srcdir" "$lapack_blddir" 
+wget -O - https://github.com/Reference-LAPACK/lapack/archive/refs/tags/v3.9.1.tar.gz | tar xzf - 
+cmake -H$lapack_srcdir -B$lapack_blddir -DCMAKE_BUILD_TYPE=Release  -DCMAKE_Fortran_FLAGS=-fno-optimize-sibling-calls  -DBUILD_TESTING=OFF  -DCBLAS=ON  -DLAPACKE=OFF
+make -j$(nproc) -C "$lapack_blddir"
+make -C "$lapack_blddir" install
+cd $lapack_blddir
+cp -r ./include/* /usr/local/include/ 
+cp -r ./lib/* /usr/local/lib 
+cd / 
+rm -rf /tmp/lapack
+
+## FMT(7.1.3v)
+## Reference https://github.com/ROCmSoftwarePlatform/rocSOLVER/blob/develop/install.sh#L152
+fmt_version=7.1.3 
+fmt_srcdir=fmt-$fmt_version
+fmt_blddir=fmt-$fmt_version-bld
+rm -rf "$fmt_srcdir" "$fmt_blddir"
+wget -O - https://github.com/fmtlib/fmt/archive/refs/tags/$fmt_version.tar.gz  | tar xzf -
+cmake -H$fmt_srcdir -B$fmt_blddir -DCMAKE_BUILD_TYPE=Release -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_EXTENSIONS=OFF -DCMAKE_CXX_STANDARD_REQUIRED=ON -DFMT_DOC=OFF -DFMT_TEST=OFF 
+make -j$(nproc) -C "$fmt_blddir" 
+make -C "$fmt_blddir" install
+
+# Build and install libjpeg-turbo
+mkdir -p /tmp/libjpeg-turbo 
+cd /tmp/libjpeg-turbo
+wget -nv https://github.com/rrawther/libjpeg-turbo/archive/refs/heads/2.0.6.2.zip -O libjpeg-turbo-2.0.6.2.zip
+unzip libjpeg-turbo-2.0.6.2.zip 
+cd libjpeg-turbo-2.0.6.2
+mkdir build 
+cd build 
+cmake -DCMAKE_INSTALL_PREFIX=/usr  -DCMAKE_BUILD_TYPE=RELEASE  -DENABLE_STATIC=FALSE  -DCMAKE_INSTALL_DEFAULT_LIBDIR=lib .. 
+make -j$(nproc) install 
+rm -rf /tmp/libjpeg-turbo
+
+# Get released ninja from source
+mkdir -p /tmp/ninja 
+cd /tmp/ninja
+wget -nv https://codeload.github.com/Kitware/ninja/zip/refs/tags/v1.11.1.g95dee.kitware.jobserver-1 -O ninja.zip 
+unzip ninja.zip 
+cd ninja-1.11.1.g95dee.kitware.jobserver-1 
+./configure.py --bootstrap
+cp ninja /usr/local/bin/ 
+rm -rf /tmp/ninja
+
+# Install pre-built FFmpeg and dependencies
+# See docker/build-deps for instructions on how to build these packages
+wget -qO- https://www.ffmpeg.org/releases/ffmpeg-4.4.2.tar.gz | tar -xzv -C /usr/local
+
+command -v lbzip2 
+ln -sf $(command -v lbzip2) /usr/local/bin/compressor || ln -sf $(command -v bzip2) /usr/local/bin/compressor
+
+# Install Google Benchmark 
+mkdir -p /tmp/Gbenchmark 
+cd /tmp/Gbenchmark 
+wget -qO- https://github.com/google/benchmark/archive/refs/tags/v1.6.1.tar.gz | tar xz 
+cmake -Sbenchmark-1.6.1 -Bbuild -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DBENCHMARK_ENABLE_TESTING=OFF -DCMAKE_CXX_STANDARD=14 
+make -j -C build 
+cd /tmp/Gbenchmark/build
+make install
+
+# Build boost-1.82.0 from source for RPP
+# Installing in a non-standard location since the test packages of hipFFT and rocFFT pick up the version of
+# the installed Boost library and declare a package dependency on that specific version of Boost.
+# For example, if this was installed in the standard location it would declare a dependency on libboost-dev(el)1.82.0
+# which is not available as a package in any distro.
+# Once this is fixed, we can remove the Boost package from the requirements list and install this
+# in the standard location
+# export RPP_DEPS_LOCATION=/usr/local/rpp-deps
+mkdir -p /tmp/boost-1.82.0 
+cd /tmp/boost-1.82.0 
+wget -nv https://sourceforge.net/projects/boost/files/boost/1.82.0/boost_1_82_0.tar.bz2 -O ./boost_1_82_0.tar.bz2 
+tar -xf boost_1_82_0.tar.bz2 --use-compress-program="/usr/local/bin/compressor" 
+cd boost_1_82_0 
+./bootstrap.sh --prefix=${RPP_DEPS_LOCATION} --with-python=python3 
+./b2 stage -j$(nproc) threading=multi link=shared cxxflags="-std=c++11" 
+./b2 install threading=multi link=shared --with-system --with-filesystem 
+./b2 stage -j$(nproc) threading=multi link=static cxxflags="-std=c++11 -fpic" cflags="-fpic" 
+./b2 install threading=multi link=static --with-system --with-filesystem 
+rm -rf /tmp/boost-1.82.0

tools/rocm-build/docker/ubuntu20/packages

@@ -0,0 +1,137 @@
+# List of packages needed for stage1 build
+apt-utils
+aria2
+autoconf
+automake
+bc
+bison
+bridge-utils
+build-essential
+bzip2
+check
+chrpath
+cifs-utils
+cpio
+curl
+devscripts
+dkms
+dos2unix
+fakeroot
+flex
+freeglut3-dev
+g++
+g++-multilib
+# gawk is needed for aomp
+gawk
+gcc
+gcc-multilib
+gfortran
+git-lfs
+gnupg
+graphviz
+kernel-wedge
+lbzip2
+# less is needed by repo
+less
+libass-dev
+libatlas-base-dev
+libbabeltrace-ctf-dev
+libbabeltrace-dev
+libboost-all-dev
+libboost-dev
+libboost-filesystem-dev
+libboost-program-options-dev
+libboost-system-dev
+libbz2-dev
+libc++-dev
+libc++1
+libc++abi-dev
+libc++abi1
+libc6-dev-i386
+libcap-dev
+libcurl4-openssl-dev
+libdrm-dev
+libdw-dev
+libdw1
+libdwarf-dev
+libelf-dev
+libelf1
+libexpat1-dev
+libfftw3-dev
+libfile-find-rule-perl
+libgflags-dev
+libglew-dev
+libgmp-dev
+libgoogle-glog-dev
+libgtk2.0-dev
+libhdf5-serial-dev
+libjpeg-dev
+libleveldb-dev
+liblmdb-dev
+liblzma-dev
+libmpfr-dev
+libmpich-dev
+libmsgpack-dev
+libncurses5-dev
+libnuma-dev
+libomp-dev
+libopenblas-base
+libopenblas-dev
+libpci-dev
+libpci3
+libpciaccess-dev
+libpciaccess0
+libprotobuf-dev
+libpython2.7-dev
+libpython3-dev
+libreadline-dev
+libsnappy-dev
+libssl-dev
+libsuitesparse-dev
+libsystemd-dev
+libtinfo-dev
+libtool
+libunwind-dev
+liburi-encode-perl
+libva-dev
+libvirt-clients
+libvirt-daemon-system
+libyaml-cpp-dev
+llvm
+llvm-6.0-dev
+llvm-dev
+llvm-runtime
+mesa-common-dev
+mpich
+ocaml
+ocaml-findlib
+patchelf
+pigz
+pkg-config
+protobuf-compiler
+python-is-python3
+python-pip-whl
+python-yaml
+python3-dev
+python3-pip
+python3-venv
+python3-yaml
+python3.8-dev
+re2c
+redis-tools
+rpm
+rsync
+ssh
+strace
+sudo
+systemtap-sdt-dev
+texinfo
+texlive
+texlive-extra-utils
+texlive-plain-generic
+texlive-xetex
+unzip
+vim
+wget
+xsltproc
+zlib1g-dev

tools/rocm-build/docker/ubuntu22/Dockerfile

@@ -0,0 +1,9 @@
+FROM ubuntu:jammy as builder
+COPY packages /tmp/packages
+COPY local-pin-600 /tmp/local-pin-600
+COPY install-prerequisities.sh /tmp/install-prerequisities.sh
+RUN chmod +x /tmp/install-prerequisities.sh
+ENV KBUILD_PKG_ROOTCMD=
+ENV RPP_DEPS_LOCATION=/usr/local/rpp-deps
+RUN  /tmp/install-prerequisities.sh
+WORKDIR /src

tools/rocm-build/docker/ubuntu22/README.md

@@ -0,0 +1,26 @@
+## Steps to build the Docker Image
+
+1. Clone this repositry
+
+   ```bash
+   git clone -b roc-6.1.x https://github.com/ROCm/ROCm.git
+   ```
+
+2. Go into the OS specific docker directory in build-infra
+
+    ```bash
+    cd ROCm/rocm-build/docker/ubuntu22
+    ```
+
+3. Build the docker image
+
+    ```bash
+    docker build -t <docker Image Name> .
+    ```
+
+    replace the `<docker Image Name>` with the new Docker image Name of your choice,
+4. After successful build, verify your \<docker Image Name\> in the list all available docker images.
+
+    ```bash
+    docker images
+    ```

tools/rocm-build/docker/ubuntu22/install-prerequisities.sh

@@ -0,0 +1,232 @@
+#! /usr/bin/bash
+
+set -ex
+
+apt-get -y update 
+DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true apt-get install --no-install-recommends -y $(sed 's/#.*//' /tmp/packages)
+apt-get clean 
+rm -rf /var/cache/apt/ /var/lib/apt/lists/* /etc/apt/apt.conf.d/01proxy
+
+#Install  2.17.1 version of git as we are seeing issues with 2.25 , where it was not allowing to add git submodules if the user is different for parent git directory
+curl -o git.tar.gz https://cdn.kernel.org/pub/software/scm/git/git-2.17.1.tar.gz 
+tar -zxf git.tar.gz 
+cd git-* 
+make prefix=/usr/local all    
+make prefix=/usr/local install
+git --version
+
+#install argparse and CppHeaderParser python modules for roctracer and rocprofiler
+#install rocm-docs-core for the docs-as-code project. Only needed on one OS
+# CppHeader needs setuptools. setuptools needs wheel.
+# Looks like I need them as seperate commands
+# Sigh, install both python2 and python 3 version
+pip3 install --no-cache-dir setuptools wheel tox
+pip3 install --no-cache-dir CppHeaderParser argparse requests lxml barectf recommonmark jinja2==3.0.0 websockets matplotlib numpy scipy minimal msgpack pytest sphinx joblib PyYAML rocm-docs-core cmake==3.25.2 pandas myst-parser
+
+# Allow sudo for everyone user
+echo 'ALL ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/everyone
+
+# Install OCaml packages to build LLVM's OCaml bindings to be used in lightning compiler test pipeline
+wget -nv https://sourceforge.net/projects/opam.mirror/files/2.1.4/opam-2.1.4-x86_64-linux -O /usr/local/bin/opam 
+chmod +x /usr/local/bin/opam
+opam init --yes --disable-sandboxing
+opam install ctypes --yes
+
+# Install and modify git-repo (#!/usr/bin/env python -> #!/usr/bin/env python3)
+curl https://storage.googleapis.com/git-repo-downloads/repo > /usr/bin/repo
+chmod a+x /usr/bin/repo
+
+# Build ccache from the source
+cd /tmp 
+git clone https://github.com/ccache/ccache -b v4.7.5 
+cd ccache 
+mkdir build 
+cd build 
+cmake -DCMAKE_BUILD_TYPE=Release .. 
+make 
+make install 
+cd /tmp 
+rm -rf ccache
+
+# Install sharp from MLNX_OFED_LINUX as dependency for rccl-rdma-sharp-plugins
+cd /var/tmp
+mkdir mlnx 
+wget -O mlnx/tar.tgz https://content.mellanox.com/ofed/MLNX_OFED-24.01-0.3.3.1/MLNX_OFED_LINUX-24.01-0.3.3.1-ubuntu22.04-x86_64.tgz 
+tar -xz -C mlnx -f mlnx/tar.tgz 
+apt-key add mlnx/*/RPM-GPG-KEY-Mellanox
+echo "deb [arch=amd64] file:$(echo $PWD/mlnx/*/DEBS) ./" > /etc/apt/sources.list.d/sharp.list
+apt update
+apt install -y sharp 
+apt clean
+rm -rf /var/cache/apt/ /var/lib/apt/lists/* mlnx /etc/apt/sources.list.d/sharp.list
+
+
+apt update
+apt -y install libunwind-dev
+apt -y install libgoogle-glog-dev
+
+# Install python3.8 from source
+curl -LO https://www.python.org/ftp/python/3.8.13/Python-3.8.13.tar.xz
+tar -xvf Python-3.8.13.tar.xz
+pwd
+ls /var/tmp/
+ls Python-3.8.13
+mv Python-3.8.13 /opt/
+apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev libffi-dev curl libbz2-dev pkg-config make -y 
+cd /opt/Python-3.8.13/ 
+./configure --enable-optimizations --enable-shared
+make 
+make -j 6 
+make altinstall 
+ldconfig /opt/Python3.8.13
+python3.8 --version
+
+# roctracer and rocprofiler needs this python3.8
+python3.8 -m pip install setuptools wheel
+python3.8 -m pip install CppHeaderParser argparse requests lxml PyYAML joblib
+
+#Install older version of hwloc-devel package for rocrtst
+curl -lO https://download.open-mpi.org/release/hwloc/v1.11/hwloc-1.11.13.tar.bz2
+tar -xvf hwloc-1.11.13.tar.bz2
+cd hwloc-1.11.13
+./configure
+make
+make install
+cp /usr/local/lib/libhwloc.so.5 /usr/lib
+hwloc-info --version
+
+# Install gtest
+mkdir -p /tmp/gtest
+cd /tmp/gtest
+wget https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip -O googletest.zip
+unzip googletest.zip
+cd googletest-1.14.0/ 
+mkdir build
+cd build
+cmake .. 
+make -j$(nproc) 
+make install
+rm -rf /tmp/gtest
+
+## Install gRPC from source
+## RDC Pre-requisites
+GRPC_ARCHIVE=grpc-1.61.0.tar.gz
+mkdir /tmp/grpc
+mkdir /usr/grpc 
+cd /tmp 
+git clone --recurse-submodules -b v1.61.0 https://github.com/grpc/grpc
+cd grpc
+mkdir -p build 
+cd build
+cmake  -DgRPC_INSTALL=ON -DBUILD_SHARED_LIBS=ON -DgRPC_BUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=/usr/grpc -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=14 .. 
+make -j $(nproc) install 
+rm -rf /tmp/grpc
+
+## rocBLAS Pre-requisites
+## Download prebuilt AMD multithreaded   (2.0)
+## Reference : https://github.com/ROCmSoftwarePlatform/rocBLAS/blob/develop/install.sh#L403
+mkdir -p /tmp/blis 
+cd /tmp/blis
+wget -O - https://github.com/amd/blis/releases/download/2.0/aocl-blis-mt-ubuntu-2.0.tar.gz | tar xfz - 
+mv amd-blis-mt /usr/blis 
+cd / 
+rm -rf /tmp/blis
+## rocBLAS Pre-requisites(SWDEV-404612)
+## Download aocl-linux-aocc-4.0_1_amd64
+mkdir -p /tmp/aocl 
+cd /tmp/aocl 
+wget -nv https://download.amd.com/developer/eula/aocl/aocl-4-0/aocl-linux-aocc-4.0_1_amd64.deb 
+apt install ./aocl-linux-aocc-4.0_1_amd64.deb 
+rm -rf /tmp/aocl
+
+## hipBLAS Pre-requisites
+## lapack(3.9.1v)
+## Reference https://github.com/ROCmSoftwarePlatform/rocSOLVER/blob/develop/install.sh#L174
+lapack_version=3.9.1
+lapack_srcdir=lapack-$lapack_version
+lapack_blddir=lapack-$lapack_version-bld
+mkdir -p /tmp/lapack
+cd /tmp/lapack
+rm -rf "$lapack_srcdir" "$lapack_blddir" 
+wget -O - https://github.com/Reference-LAPACK/lapack/archive/refs/tags/v3.9.1.tar.gz | tar xzf - 
+cmake -H$lapack_srcdir -B$lapack_blddir -DCMAKE_BUILD_TYPE=Release -DCMAKE_Fortran_FLAGS=-fno-optimize-sibling-calls -DBUILD_TESTING=OFF -DCBLAS=ON -DLAPACKE=OFF
+make -j$(nproc) -C "$lapack_blddir"
+make -C "$lapack_blddir" install
+cd $lapack_blddir
+cp -r ./include/* /usr/local/include/ 
+cp -r ./lib/* /usr/local/lib 
+cd / 
+rm -rf /tmp/lapack
+
+## rocSOLVER Pre-requisites
+## FMT(7.1.3v)
+## Reference https://github.com/ROCmSoftwarePlatform/rocSOLVER/blob/develop/install.sh#L152
+fmt_version=7.1.3
+fmt_srcdir=fmt-$fmt_version
+fmt_blddir=fmt-$fmt_version-bld
+mkdir -p /tmp/fmt
+cd /tmp/fmt
+rm -rf "$fmt_srcdir" "$fmt_blddir"
+wget -O - https://github.com/fmtlib/fmt/archive/refs/tags/7.1.3.tar.gz | tar xzf -
+cmake -H$fmt_srcdir -B$fmt_blddir -DCMAKE_BUILD_TYPE=Release -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_EXTENSIONS=OFF -DCMAKE_CXX_STANDARD_REQUIRED=ON -DFMT_DOC=OFF -DFMT_TEST=OFF
+make -j$(nproc) -C "$fmt_blddir"
+make -C "$fmt_blddir" install
+
+# Build and install libjpeg-turbo
+mkdir -p /tmp/libjpeg-turbo 
+cd /tmp/libjpeg-turbo 
+wget -nv https://github.com/rrawther/libjpeg-turbo/archive/refs/heads/2.0.6.2.zip -O libjpeg-turbo-2.0.6.2.zip
+unzip libjpeg-turbo-2.0.6.2.zip 
+cd libjpeg-turbo-2.0.6.2
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=RELEASE -DENABLE_STATIC=FALSE -DCMAKE_INSTALL_DEFAULT_LIBDIR=lib .. 
+make -j$(nproc) install 
+rm -rf /tmp/libjpeg-turbo
+
+# Get released ninja from source
+mkdir -p /tmp/ninja 
+cd /tmp/ninja 
+wget -nv https://codeload.github.com/Kitware/ninja/zip/refs/tags/v1.11.1.g95dee.kitware.jobserver-1 -O ninja.zip
+unzip ninja.zip
+cd ninja-1.11.1.g95dee.kitware.jobserver-1
+./configure.py --bootstrap 
+cp ninja /usr/local/bin/ 
+rm -rf /tmp/ninja
+
+# Install pre-built FFmpeg and dependencies
+# See docker/build-deps for instructions on how to build these packages
+wget -qO- https://www.ffmpeg.org/releases/ffmpeg-4.4.2.tar.gz  | tar -xzv -C /usr/local
+
+cp /tmp/local-pin-600 /etc/apt/preferences.d
+
+command -v lbzip2 
+ln -sf $(command -v lbzip2) /usr/local/bin/compressor || ln -sf $(command -v bzip2) /usr/local/bin/compressor
+
+# Install Google Benchmark
+mkdir -p /tmp/Gbenchmark 
+cd /tmp/Gbenchmark 
+wget -qO- https://github.com/google/benchmark/archive/refs/tags/v1.6.1.tar.gz | tar xz 
+cmake -Sbenchmark-1.6.1 -Bbuild -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DBENCHMARK_ENABLE_TESTING=OFF -DCMAKE_CXX_STANDARD=14 
+make -j -C build 
+cd /tmp/Gbenchmark/build
+make install
+
+# Build boost-1.82.0 from source for RPP
+# Installing in a non-standard location since the test packages of hipFFT and rocFFT pick up the version of
+# the installed Boost library and declare a package dependency on that specific version of Boost.
+# For example, if this was installed in the standard location it would declare a dependency on libboost-dev(el)1.82.0
+# which is not available as a package in any distro.
+# Once this is fixed, we can remove the Boost package from the requirements list and install this
+# in the standard location
+mkdir -p /tmp/boost-1.82.0 
+cd /tmp/boost-1.82.0 
+wget -nv https://sourceforge.net/projects/boost/files/boost/1.82.0/boost_1_82_0.tar.bz2 -O ./boost_1_82_0.tar.bz2 
+tar -xf boost_1_82_0.tar.bz2 --use-compress-program="/usr/local/bin/compressor" 
+cd boost_1_82_0 
+./bootstrap.sh --prefix=${RPP_DEPS_LOCATION} --with-python=python3 
+./b2 stage -j$(nproc) threading=multi link=shared cxxflags="-std=c++11" 
+./b2 install threading=multi link=shared --with-system --with-filesystem 
+./b2 stage -j$(nproc) threading=multi link=static cxxflags="-std=c++11 -fpic" cflags="-fpic"
+./b2 install threading=multi link=static --with-system --with-filesystem 
+rm -rf /tmp/boost-1.82.0

tools/rocm-build/docker/ubuntu22/local-pin-600

@@ -0,0 +1,3 @@
+Package: *
+Pin: origin ""
+Pin-Priority: 600

tools/rocm-build/docker/ubuntu22/packages

@@ -0,0 +1,139 @@
+# List of packages needed for stage1 build
+apt-utils
+aria2
+autoconf
+automake
+bc
+bison
+bridge-utils
+build-essential
+bzip2
+check
+chrpath
+cifs-utils
+cpio
+curl
+devscripts
+dos2unix
+doxygen
+fakeroot
+flex
+freeglut3-dev
+g++
+g++-multilib
+# gawk is needed for aomp
+gawk
+gcc
+gcc-multilib
+gfortran
+git-lfs
+gnupg
+googletest-tools
+graphviz
+grpc-proto
+kernel-wedge
+# kmod for kernel build
+kmod
+lbzip2
+# less is needed by repo
+less
+libass-dev
+libatlas-base-dev
+libbabeltrace-ctf-dev
+libbabeltrace-dev
+libboost-all-dev
+libboost-dev
+libboost-filesystem-dev
+libboost-program-options-dev
+libboost-system-dev
+libbz2-dev
+libc++-dev
+libc++1
+libc++abi-dev
+libc++abi1
+libc6-dev-i386
+libcap-dev
+libcurl4-openssl-dev
+libdrm-dev
+libdw-dev
+libdw1
+libdwarf-dev
+libelf-dev
+libelf1
+libexpat1-dev
+libfftw3-dev
+libfile-find-rule-perl
+libgflags-dev
+libglew-dev
+libgmp-dev
+libgtk2.0-dev
+libhdf5-serial-dev
+libjpeg-dev
+libleveldb-dev
+liblmdb-dev
+liblzma-dev
+libmpfr-dev
+libmpich-dev
+libmsgpack-dev
+libncurses5-dev
+libnuma-dev
+libomp-dev
+libopenblas-base
+libopenblas-dev
+libpci-dev
+libpci3
+libpciaccess-dev
+libpciaccess0
+libprotobuf-dev
+libpython2.7-dev
+libpython3-dev
+libreadline-dev
+libsnappy-dev
+libssl-dev
+libsuitesparse-dev
+libsystemd-dev
+libtinfo-dev
+libtool
+liburi-encode-perl
+libva-dev
+libvirt-clients
+libvirt-daemon-system
+libyaml-cpp-dev
+llvm
+llvm-dev
+llvm-runtime
+mesa-common-dev
+mpich
+ocaml
+ocaml-findlib
+patchelf
+pigz
+pkg-config
+protobuf-compiler
+python-is-python3
+python3-dev
+python3-pip
+python3-pip-whl
+python3-venv
+python3-yaml
+python3-yaml
+python3.8-dev
+re2c
+redis-tools
+# hipclang needs rpm
+rpm
+rsync
+ssh
+# This makes life more pleasent inside the container
+strace
+sudo
+systemtap-sdt-dev
+texinfo
+texlive
+texlive-extra-utils
+texlive-plain-generic
+texlive-xetex
+unzip
+vim
+wget
+xsltproc

tools/rocm-build/envsetup.sh

@@ -0,0 +1,191 @@
+#!/bin/bash
+
+set_WORK_ROOT(){
+    [ -n "$WORK_ROOT" ] && return 0
+    export WORK_ROOT=$PWD
+    while :; do
+	[ -d "$WORK_ROOT/.repo/manifests" ] && return 0
+        WORK_ROOT=$WORK_ROOT/..
+	( cd -P "$WORK_ROOT" &&  [ "$PWD" != "/" ] ) || break
+    done
+    echo "Unable to find a .repo/manifests directory above '$PWD'" >&2
+    unset WORK_ROOT		# No point in saying we have one when we don't
+    return 1
+}
+set_WORK_ROOT || exit 2
+
+if [ "$DASH_JAY" == "" ]; then
+    if [ -x "$(command -v nproc)" ]; then
+        export DASH_JAY="-j $(nproc)"
+    else
+        export DASH_JAY="-j 4"
+    fi
+fi
+
+export JOB_NAME=release
+export JOB_DESIGNATOR=
+echo "JOB_DESIGNATOR=${JOB_DESIGNATOR}"
+export SLES_BUILD_ID_PREFIX
+echo "SLES_BUILD_ID_PREFIX=${SLES_BUILD_ID_PREFIX}"
+
+if [ -z "${BUILD_ID}" ]; then
+    export BUILD_ID=9999
+fi
+
+if [ -n "${JOB_NAME}" ]; then
+    export ROCM_BUILD_ID=${JOB_NAME/compute-/}-${BUILD_ID}
+fi
+
+source /etc/os-release
+#re-export the variables with less generic names
+export DISTRO_NAME=$ID
+export DISTRO_RELEASE=$VERSION_ID
+export DISTRO_ID=$ID-$VERSION_ID
+
+case "${DISTRO_NAME}" in
+    ("ubuntu") export CPACKGEN=DEB PACKAGEEXT=deb PKGTYPE=deb ROCM_PKGTYPE=DEB ;;
+    ("centos") export CPACKGEN=RPM PACKAGEEXT=rpm PKGTYPE=rpm ;;
+    ("sles") export CPACKGEN=RPM PACKAGEEXT=rpm PKGTYPE=rpm ;;
+    ("rhel") export CPACKGEN=RPM PACKAGEEXT=rpm PKGTYPE=rpm ;;
+    ("mariner") export CPACKGEN=RPM PACKAGEEXT=rpm PKGTYPE=rpm ;;
+esac
+
+# set up package file name variables for CPACK_GENERATOR
+# rpm packages name are set with jenkins job designator and build no
+# deb package is appendeded with OS version as well
+export CPACK_DEBIAN_PACKAGE_RELEASE="${JOB_DESIGNATOR}${SLES_BUILD_ID_PREFIX}${BUILD_ID}~$VERSION_ID"
+export CPACK_RPM_PACKAGE_RELEASE="${JOB_DESIGNATOR}${SLES_BUILD_ID_PREFIX}${BUILD_ID}"
+
+OUT_DIR="${OUT_DIR:=$WORK_ROOT/out/$DISTRO_ID/$DISTRO_RELEASE}"
+export OUT_DIR
+export RT_TMP=$OUT_DIR/tmp/rt
+
+#source transform, for things like ocl_lc
+export SRC_TF_ROOT=$OUT_DIR/srctf
+
+# Read ROCm Version and calculate ROCm libpatch version from rocm_version.txt
+# Using logic from calculateRocmPatchVersion() in common.gvy
+get_rocm_libpatch_version() {
+    rocm_version=$1
+    if [[ "${rocm_version}" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+        libpatch_version=${rocm_version//\./0}
+        echo "${libpatch_version}"
+    else
+        echo "Invalid ROCm Version: ${rocm_version}"
+        exit 10
+    fi
+}
+
+# Read the default ROCm version from rocm_version.txt if the ROCM_VERSION
+# variable is either not set, empty or only contains spaces.
+if [ -f "${WORK_ROOT}/build/rocm_version.txt" ] && [ -z $ROCM_VERSION ]; then
+    ROCM_VERSION="$(cat ${WORK_ROOT}/build/rocm_version.txt)"
+fi
+
+: ${ROCM_VERSION:="6.1.0"}
+ROCM_LIBPATCH_VERSION=$(get_rocm_libpatch_version $ROCM_VERSION)
+echo "ROCM_VERSION=${ROCM_VERSION}"
+echo "ROCM_LIBPATCH_VERSION=${ROCM_LIBPATCH_VERSION}"
+export ROCM_VERSION ROCM_LIBPATCH_VERSION
+
+export ROCM_INSTALL_PATH="/opt/rocm-${ROCM_VERSION}-${BUILD_ID}"
+# check if the job = release
+if [[ "${JOB_NAME}" == *rel* ]]; then
+    export ROCM_INSTALL_PATH="/opt/rocm-${ROCM_VERSION}"
+fi
+
+# Setting the ROCM_INSTALL_PATH id to Last Know Good build ID, PSDB incremental built packages will install into /opt/rocm-<parent build ID>
+if [ -n "${LKG_BUILD_ID}" ]; then
+    export ROCM_INSTALL_PATH="/opt/rocm-${ROCM_VERSION}-${LKG_BUILD_ID}"
+fi
+
+echo "Setting ROCM_INSTALL_PATH=${ROCM_INSTALL_PATH}"
+
+export ROCM_PATH="$ROCM_INSTALL_PATH"
+export ROCM_LIBPATH=""
+export DEVTOOLSET_LIBPATH="/opt/rh/devtoolset-7/root/usr/lib64;/opt/rh/devtoolset-7/root/usr/lib"
+
+# Source directories
+# TODO: We should have autodiscoverable makefiles
+export DIST_NO_DEBUG=yes
+export OPENCL_MAINLINE=1
+export HSA_SOURCE_ROOT=$WORK_ROOT/ROCR-Runtime
+export HSA_OPENSOURCE_ROOT=$HSA_SOURCE_ROOT/src
+export ROCRTST_ROOT=$HSA_SOURCE_ROOT/rocrtst
+export HSA_CORE_ROOT=$HSA_OPENSOURCE_ROOT
+export HSA_IMAGE_ROOT=$HSA_OPENSOURCE_ROOT/hsa-ext-image
+export HSA_FINALIZE_ROOT=$HSA_OPENSOURCE_ROOT/hsa-ext-finalize
+export HSA_TOOLS_ROOT=$HSA_OPENSOURCE_ROOT/hsa-runtime-tools
+export OCL_RT_SRC_TF_ROOT=$SRC_TF_ROOT/ocl_lc
+export SCRIPT_ROOT=$WORK_ROOT/build
+export THUNK_ROOT=$WORK_ROOT/ROCT-Thunk-Interface
+if [ -d "$HSA_OPENSOURCE_ROOT/ROCT-Thunk-Interface" ]; then
+	export THUNK_ROOT=$HSA_OPENSOURCE_ROOT/ROCT-Thunk-Interface
+fi
+export AQLPROFILE_ROOT=$WORK_ROOT/hsa/aqlprofile
+export ROCPROFILER_ROOT=$WORK_ROOT/rocprofiler
+export ROCTRACER_ROOT=$WORK_ROOT/roctracer
+export ROCPROFILER_REGISTER_ROOT=$WORK_ROOT/rocprofiler-register
+export RDC_ROOT=$WORK_ROOT/rdc
+export RDCTST_ROOT=$RDC_ROOT/tests/rdc_tests
+export UTILS_ROOT=$WORK_ROOT/rocm-utils
+export KFDTEST_ROOT=$THUNK_ROOT/tests/kfdtest
+if [ -d "$HSA_OPENSOURCE_ROOT/tests/kfdtest" ]; then
+	export KFDTEST_ROOT=$HSA_OPENSOURCE_ROOT/tests/kfdtest
+fi
+export HIPIFY_ROOT=$WORK_ROOT/HIPIFY
+export AMD_SMI_LIB_ROOT=$WORK_ROOT/amdsmi
+export ROCM_SMI_LIB_ROOT=$WORK_ROOT/rocm_smi_lib
+export RSMITST_ROOT=$ROCM_SMI_LIB_ROOT/tests/rocm_smi_test
+export LLVM_PROJECT_ROOT=$WORK_ROOT/llvm-project
+export LLVM_ROOT=$LLVM_PROJECT_ROOT/llvm
+export CLANG_ROOT=$LLVM_PROJECT_ROOT/clang
+export LLD_ROOT=$LLVM_PROJECT_ROOT/lld
+export HIPCC_ROOT=$LLVM_PROJECT_ROOT/amd/hipcc
+export DEVICELIBS_ROOT=$LLVM_PROJECT_ROOT/amd/device-libs
+export ROCM_CORE_ROOT=$WORK_ROOT/rocm-core
+export ROCM_CMAKE_ROOT=$WORK_ROOT/rocm-cmake
+export ROCM_BANDWIDTH_TEST_ROOT=$WORK_ROOT/rocm_bandwidth_test
+export ROCMINFO_ROOT=$WORK_ROOT/rocminfo
+export CLANG_OCL_ROOT=$WORK_ROOT/clang-ocl
+export ROCR_DEBUG_AGENT_ROOT=$WORK_ROOT/rocr_debug_agent
+export COMGR_ROOT=$LLVM_PROJECT_ROOT/amd/comgr
+export COMGR_LIB_PATH=$OUT_DIR/build/amd_comgr
+export RCCL_ROOT=$WORK_ROOT/rccl
+export ROCM_DBGAPI_ROOT=$WORK_ROOT/ROCdbgapi
+export ROCM_GDB_ROOT=$WORK_ROOT/ROCgdb
+export HIP_ON_ROCclr_ROOT=$WORK_ROOT/HIP
+export HIPAMD_ROOT=$WORK_ROOT/hipamd
+export HIP_CATCH_TESTS_ROOT=$WORK_ROOT/hip-tests
+export CLR_ROOT=$WORK_ROOT/clr
+export AOMP_REPOS=$WORK_ROOT/openmp-extras
+export HIPOTHER_ROOT=$WORK_ROOT/hipother
+
+# For libraries $ORIGIN
+# For binaries $ORIGIN/../lib
+export ROCM_LIB_RPATH='$ORIGIN'
+export ROCM_EXE_RPATH='$ORIGIN/../lib'
+
+# For ASAN Libraries since the asan lib path is lib/asan/
+export ROCM_ASAN_LIB_RPATH='$ORIGIN:$ORIGIN/..'
+export ROCM_ASAN_EXE_RPATH="\$ORIGIN/../lib/asan:\$ORIGIN/../lib"
+
+export PATH=$PATH:$SCRIPT_ROOT
+
+# From setup_env.sh
+export LIBS_WORK_DIR=$WORK_ROOT
+export BUILD_ARTIFACTS=$OUT_DIR/$PACKAGEEXT
+
+export HIPCC_COMPILE_FLAGS_APPEND="-O3 -Wno-format-nonliteral -parallel-jobs=4"
+export HIPCC_LINK_FLAGS_APPEND="-O3 -parallel-jobs=4"
+
+export PATH="${ROCM_PATH}/lib/llvm/bin:${PATH}"
+
+export LC_ALL=C.UTF-8
+export LANG=C.UTF-8
+
+export PROC=${PROC:-"$(nproc)"}
+export RELEASE_FLAG=${RELEASE_FLAG:-"-r"}
+export SUDO=sudo
+export PATH=/usr/local/bin:${PATH}:${HOME}/.local/bin
+export CCACHE_DIR=${HOME}/.ccache

tools/rocm-build/post_inst_pkg.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+set -x
+
+
+UNTAR_COMPONENT_NAME=$1
+
+
+copy_pkg_files_to_rocm() {
+    local comp_folder=$1
+    local comp_pkg_name=$2
+
+    cd "${OUT_DIR}/${PKGTYPE}/${comp_folder}"|| exit 2
+    if [ "${PKGTYPE}" = 'deb' ]; then
+        dpkg-deb -x ${comp_pkg_name}_*.deb pkg/
+    else
+        mkdir pkg && pushd pkg/ || exit 2
+        if [[ "${comp_pkg_name}" != *-dev* ]]; then
+            rpm2cpio ../${comp_pkg_name}-*.rpm | cpio -idmv
+        else
+            rpm2cpio ../${comp_pkg_name}el-*.rpm | cpio -idmv
+        fi
+        popd || exit 2
+    fi
+    ls ./pkg -alt
+    ${SUDO} cp -r ./pkg${ROCM_PATH}/* "${ROCM_PATH}" || exit 2
+    rm -rf pkg/
+}
+
+get_os_name() {
+    local os_name
+    os_name=$(grep -oP '^NAME="\K.*(?=")' < /etc/os-release)
+    echo "${os_name,,}"
+}
+
+set_pkg_type() {
+    local os_name
+    os_name=$(grep -oP '^NAME="\K.*(?=")' < /etc/os-release)
+    [ "${os_name,,}" = ubuntu ] && echo "deb" || echo "rpm"
+}
+
+setup_rocm_compilers_hash_file() {
+    local clang_version
+    clang_version="$("${ROCM_PATH}/llvm/bin/clang" --version | head -n 1)"
+    printf '%s: %s\n' 'clang version' "${clang_version}" | tee "${OUT_DIR}/rocm_compilers_hash_file"
+}
+
+PKGTYPE=$(set_pkg_type)
+
+case $UNTAR_COMPONENT_NAME in
+    (lightning)
+        if [ "${CCACHE_ENABLED}" == "true" ] ; then
+            setup_rocm_compilers_hash_file
+        fi
+
+        mkdir -p ${ROCM_PATH}/bin
+        printf '%s\n' > ${ROCM_PATH}/bin/target.lst gfx900 gfx906 gfx908 gfx803 gfx1030
+
+        if [ -e "${ROCM_PATH}/lib/llvm/bin/rocm.cfg" ]; then
+            sed -i '/-frtlib-add-rpath/d' ${ROCM_PATH}/lib/llvm/bin/rocm.cfg
+        elif [ -e "${ROCM_PATH}/llvm/bin/rocm.cfg" ]; then
+            sed -i '/-frtlib-add-rpath/d' ${ROCM_PATH}/llvm/bin/rocm.cfg
+        fi
+        ;;
+    (hipify_clang)
+        copy_pkg_files_to_rocm hipify hipify-clang
+        ;;
+    (hip_on_rocclr)
+        rm -f ${ROCM_PATH}/bin/hipcc.bat
+        ;;
+    (openmp_extras)
+        copy_pkg_files_to_rocm openmp-extras openmp-extras-runtime
+        copy_pkg_files_to_rocm openmp-extras openmp-extras-dev
+        ;;
+    (rocblas)
+        copy_pkg_files_to_rocm rocblas rocblas-dev
+        ;;
+    (*)
+        echo "post processing is not required for ${UNTAR_COMPONENT_NAME}"
+        ;;
+esac
+

tools/rocm-build/rocm-6.1.0.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest>
+    <remote name="rocm-org" fetch="https://github.com/ROCm/" />
+    <default revision="refs/tags/rocm-6.1.0"
+     remote="rocm-org"
+     sync-c="true"
+     sync-j="4" />
+<!--list of projects for ROCm-->
+    <project name="ROCm" revision="roc-6.1.x" />
+    <project name="ROCK-Kernel-Driver" />
+    <project name="ROCT-Thunk-Interface" />
+    <project name="ROCR-Runtime" />
+    <project name="amdsmi" />
+    <project name="rocm_smi_lib" />
+    <project name="rocm-core" />
+    <project name="rocm-cmake" />
+    <project name="rocminfo" />
+    <project name="rocm_bandwidth_test" />
+    <project name="rocprofiler" />
+    <project name="rocprofiler-register" />
+    <project name="roctracer" />
+    <project name="clang-ocl" />
+    <project name="rdc" />
+<!--HIP Projects-->
+    <project name="HIP" />
+    <project name="hip-tests" />
+    <project name="HIP-Examples" />
+    <project name="clr" />
+    <project name="hipother" />
+    <project name="HIPIFY" />
+<!-- The following projects are all associated with the AMDGPU LLVM compiler -->
+    <project name="llvm-project" />
+    <project name="half" />
+<!-- gdb projects -->
+    <project name="ROCgdb" />
+    <project name="ROCdbgapi" />
+    <project name="rocr_debug_agent" />
+<!-- ROCm Libraries -->
+    <project groups="mathlibs" name="rocBLAS" />
+    <project groups="mathlibs" name="Tensile" />
+    <project groups="mathlibs" name="hipTensor" />
+    <project groups="mathlibs" name="hipBLAS" />
+    <project groups="mathlibs" name="hipBLASLt" />
+    <project groups="mathlibs" name="rocFFT" />
+    <project groups="mathlibs" name="hipFFT" />
+    <project groups="mathlibs" name="rocRAND" />
+    <project groups="mathlibs" name="hipRAND" />
+    <project groups="mathlibs" name="rocSPARSE" />
+    <project groups="mathlibs" name="hipSPARSELt" />
+    <project groups="mathlibs" name="rocSOLVER" />
+    <project groups="mathlibs" name="hipSOLVER" />
+    <project groups="mathlibs" name="hipSPARSE" />
+    <project groups="mathlibs" name="rocALUTION" />
+    <project groups="mathlibs" name="rocThrust" />
+    <project groups="mathlibs" name="hipCUB" />
+    <project groups="mathlibs" name="rocPRIM" />
+    <project groups="mathlibs" name="rocWMMA" />
+    <project groups="mathlibs" name="rccl" />
+    <project groups="mathlibs" name="MIOpen" />
+    <project groups="mathlibs" name="MIVisionX" />
+    <project groups="mathlibs" name="ROCmValidationSuite" />
+    <project groups="mathlibs" name="composable_kernel" />
+    <project groups="mathlibs" name="hipfort" />
+    <project groups="mathlibs" name="rocDecode" />
+    <project groups="mathlibs" name="AMDMIGraphX" />
+    <project groups="mathlibs" name="rpp" />
+<!-- Projects for OpenMP-Extras -->
+    <project name="aomp" path="openmp-extras/aomp" />
+    <project name="aomp-extras" path="openmp-extras/aomp-extras" />
+    <project name="flang" path="openmp-extras/flang" />
+</manifest>

tools/rocm-build/rocm-6.1.1.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest>
+    <remote name="rocm-org" fetch="https://github.com/ROCm/" />
+    <default revision="refs/tags/rocm-6.1.1"
+     remote="rocm-org"
+     sync-c="true"
+     sync-j="4" />
+<!--list of projects for ROCm-->
+    <project name="ROCm" revision="roc-6.1.x" />
+    <project name="ROCK-Kernel-Driver" />
+    <project name="ROCT-Thunk-Interface" />
+    <project name="ROCR-Runtime" />
+    <project name="amdsmi" />
+    <project name="rocm_smi_lib" />
+    <project name="rocm-core" />
+    <project name="rocm-cmake" />
+    <project name="rocminfo" />
+    <project name="rocm_bandwidth_test" />
+    <project name="rocprofiler" />
+    <project name="rocprofiler-register" />
+    <project name="roctracer" />
+    <project name="clang-ocl" />
+    <project name="rdc" />
+<!--HIP Projects-->
+    <project name="HIP" />
+    <project name="hip-tests" />
+    <project name="HIP-Examples" />
+    <project name="clr" />
+    <project name="hipother" />
+    <project name="HIPIFY" />
+<!-- The following projects are all associated with the AMDGPU LLVM compiler -->
+    <project name="llvm-project" />
+    <project name="half" />
+<!-- gdb projects -->
+    <project name="ROCgdb" />
+    <project name="ROCdbgapi" />
+    <project name="rocr_debug_agent" />
+<!-- ROCm Libraries -->
+    <project groups="mathlibs" name="rocBLAS" />
+    <project groups="mathlibs" name="Tensile" />
+    <project groups="mathlibs" name="hipTensor" />
+    <project groups="mathlibs" name="hipBLAS" />
+    <project groups="mathlibs" name="hipBLASLt" />
+    <project groups="mathlibs" name="rocFFT" />
+    <project groups="mathlibs" name="hipFFT" />
+    <project groups="mathlibs" name="rocRAND" />
+    <project groups="mathlibs" name="hipRAND" />
+    <project groups="mathlibs" name="rocSPARSE" />
+    <project groups="mathlibs" name="hipSPARSELt" />
+    <project groups="mathlibs" name="rocSOLVER" />
+    <project groups="mathlibs" name="hipSOLVER" />
+    <project groups="mathlibs" name="hipSPARSE" />
+    <project groups="mathlibs" name="rocALUTION" />
+    <project groups="mathlibs" name="rocThrust" />
+    <project groups="mathlibs" name="hipCUB" />
+    <project groups="mathlibs" name="rocPRIM" />
+    <project groups="mathlibs" name="rocWMMA" />
+    <project groups="mathlibs" name="rccl" />
+    <project groups="mathlibs" name="MIOpen" />
+    <project groups="mathlibs" name="MIVisionX" />
+    <project groups="mathlibs" name="ROCmValidationSuite" />
+    <project groups="mathlibs" name="composable_kernel" />
+    <project groups="mathlibs" name="hipfort" />
+    <project groups="mathlibs" name="rocDecode" />
+    <project groups="mathlibs" name="AMDMIGraphX" />
+    <project groups="mathlibs" name="rpp" />
+<!-- Projects for OpenMP-Extras -->
+    <project name="aomp" path="openmp-extras/aomp" />
+    <project name="aomp-extras" path="openmp-extras/aomp-extras" />
+    <project name="flang" path="openmp-extras/flang" />
+</manifest>

tools/rocm-build/rocm-6.1.2.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest>
+    <remote name="rocm-org" fetch="https://github.com/ROCm/" />
+    <default revision="refs/tags/rocm-6.1.2"
+     remote="rocm-org"
+     sync-c="true"
+     sync-j="4" />
+<!--list of projects for ROCm-->
+    <project name="ROCm" revision="roc-6.1.x" />
+    <project name="ROCK-Kernel-Driver" />
+    <project name="ROCT-Thunk-Interface" />
+    <project name="ROCR-Runtime" />
+    <project name="amdsmi" />
+    <project name="rocm_smi_lib" />
+    <project name="rocm-core" />
+    <project name="rocm-cmake" />
+    <project name="rocminfo" />
+    <project name="rocm_bandwidth_test" />
+    <project name="rocprofiler" />
+    <project name="rocprofiler-register" />
+    <project name="roctracer" />
+    <project name="clang-ocl" />
+    <project name="rdc" />
+<!--HIP Projects-->
+    <project name="HIP" />
+    <project name="hip-tests" />
+    <project name="HIP-Examples" />
+    <project name="clr" />
+    <project name="hipother" />
+    <project name="HIPIFY" />
+<!-- The following projects are all associated with the AMDGPU LLVM compiler -->
+    <project name="llvm-project" />
+    <project name="half" />
+<!-- gdb projects -->
+    <project name="ROCgdb" />
+    <project name="ROCdbgapi" />
+    <project name="rocr_debug_agent" />
+<!-- ROCm Libraries -->
+    <project groups="mathlibs" name="rocBLAS" />
+    <project groups="mathlibs" name="Tensile" />
+    <project groups="mathlibs" name="hipTensor" />
+    <project groups="mathlibs" name="hipBLAS" />
+    <project groups="mathlibs" name="hipBLASLt" />
+    <project groups="mathlibs" name="rocFFT" />
+    <project groups="mathlibs" name="hipFFT" />
+    <project groups="mathlibs" name="rocRAND" />
+    <project groups="mathlibs" name="hipRAND" />
+    <project groups="mathlibs" name="rocSPARSE" />
+    <project groups="mathlibs" name="hipSPARSELt" />
+    <project groups="mathlibs" name="rocSOLVER" />
+    <project groups="mathlibs" name="hipSOLVER" />
+    <project groups="mathlibs" name="hipSPARSE" />
+    <project groups="mathlibs" name="rocALUTION" />
+    <project groups="mathlibs" name="rocThrust" />
+    <project groups="mathlibs" name="hipCUB" />
+    <project groups="mathlibs" name="rocPRIM" />
+    <project groups="mathlibs" name="rocWMMA" />
+    <project groups="mathlibs" name="rccl" />
+    <project groups="mathlibs" name="MIOpen" />
+    <project groups="mathlibs" name="MIVisionX" />
+    <project groups="mathlibs" name="ROCmValidationSuite" />
+    <project groups="mathlibs" name="composable_kernel" />
+    <project groups="mathlibs" name="hipfort" />
+    <project groups="mathlibs" name="rocDecode" />
+    <project groups="mathlibs" name="AMDMIGraphX" />
+    <project groups="mathlibs" name="rpp" />
+<!-- Projects for OpenMP-Extras -->
+    <project name="aomp" path="openmp-extras/aomp" />
+    <project name="aomp-extras" path="openmp-extras/aomp-extras" />
+    <project name="flang" path="openmp-extras/flang" />
+</manifest>

tools/rocm-build/upload_packages.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -x
+
+
+BUILD_COMPONENT="$1"
+PACKAGEEXT=${PACKAGEEXT:-$2}
+
+COMP_DIR=$(./${INFRA_REPO}/build/build_${BUILD_COMPONENT}.sh -o ${PACKAGEEXT})
+
+TARGET_ARTI_URL=${TARGET_ARTI_URL:-$3}
+
+
+[ -z "$JFROG_TOKEN" ] && echo "JFrog token is not set, skip uploading..." && exit 0
+[ -z "$TARGET_ARTI_URL" ] && echo "Target URL is not set, skip uploading..." && exit 0
+[ -z "$COMP_DIR" ] && echo "No packages in ${BUILD_COMPONENT}" && exit 0
+[ ! -d "$COMP_DIR" ] && echo "NO ${COMP_DIR} folder..." && exit 0
+
+PKG_NAME_LIST=( "${COMP_DIR}"/* )
+
+for pkg in "${PKG_NAME_LIST[@]}"; do
+    if [[ "${ENABLE_ADDRESS_SANITIZER}" != "true" ]] || [[ "${pkg##*/}" =~ "-asan" ]]; then
+        echo "Uploading $pkg ..."
+        if ! curl -f -H "X-JFrog-Art-Api:${JFROG_TOKEN}" \
+                -X PUT "${TARGET_ARTI_URL}/$(basename ${pkg})" \
+                -T "${COMP_DIR}/$(basename ${pkg})"; then
+            echo "Unable to upload $pkg ..." >&2 && exit 1
+        fi
+        echo "$pkg uploaded..."
+    fi
+done
+