Source: llvm-toolchain-rocm
Section: devel
Priority: optional
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
XSBC-Original-Maintainer: Tom Rix <Tom.Rix@amd.com>
Uploaders: Talha Can Havadar <talha.can.havadar@canonical.com>,
           Tom Rix <Tom.Rix@amd.com>,
           Tim Flink <tflink@tirfa.com>
Build-Depends: debhelper-compat (= 13),
               dh-exec,
               binutils-dev,
               chrpath,
               cmake,
               diffstat,
               help2man,
               lcov,
               libelf-dev,
               libffi-dev,
               libjsoncpp-dev,
               libxml2-dev,
               libzstd-dev,
               lsb-release,
               ninja-build,
               patchutils,
               pkgconf,
               procps,
               sharutils,
               texinfo,
               time,
               xz-utils,
               zlib1g-dev
Build-Conflicts: oprofile
Standards-Version: 4.7.3
Homepage: https://rocm.docs.amd.com/projects/llvm-project/en/latest/index.html
Vcs-Git: https://git.launchpad.net/~bullwinkle-team/ubuntu/+source/llvm-toolchain-rocm
Vcs-Browser: https://code.launchpad.net/~bullwinkle-team/ubuntu/+source/llvm-toolchain-rocm/+git/llvm-toolchain-rocm

# ------------- clang -------------

Package: clang-rocm
Architecture: amd64
Depends: binutils,
         libc6-dev,
         libclang-common-rocm-dev (= ${binary:Version}),
         libclang1-rocm (= ${binary:Version}),
         libllvm-rocm (= ${binary:Version}),
         ${dep:devlibs-objc},
         ${dep:devlibs},
         ${misc:Depends},
         ${shlibs:Depends}
Provides: c++-compiler, c-compiler, objc++-compiler, objc-compiler
Recommends: clang-tools-rocm, llvm-rocm-dev
Description: C, C++ and Objective-C compiler
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.

Package: clang-tools-rocm
Architecture: amd64
Depends: clang-rocm (= ${binary:Version}),
         python3,
         ${misc:Depends},
         ${shlibs:Depends}
Description: clang-based tools for C/C++ developments
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.
 .
 This package contains some clang-based tools like scan-build, clang-cl, etc.

Package: clang-format-rocm
Architecture: amd64
Depends: libllvm-rocm (= ${binary:Version}),
         python3,
         ${misc:Depends},
         ${shlibs:Depends}
Description: Tool to format C/C++/Obj-C code
 Clang-format is both a library and a stand-alone tool with the goal of
 automatically reformatting C++ sources files according to configurable
 style guides. To do so, clang-format uses Clang's Lexer to transform an
 input file into a token stream and then changes all the whitespace around
 those tokens. The goal is for clang-format to both serve both as a user
 tool (ideally with powerful IDE integrations) and part of other
 refactoring tools, e.g. to do a reformatting of all the lines changed
 during a renaming.
 .
 This package also provides vim and emacs plugins.

Package: clang-tidy-rocm
Architecture: amd64
Depends: clang-tools-rocm,
         libclang-common-rocm-dev (= ${binary:Version}),
         libllvm-rocm (= ${binary:Version}),
         python3,
         python3-yaml,
         ${misc:Depends},
         ${shlibs:Depends}
Description: clang-based C++ linter tool
 Provide an extensible framework for diagnosing and fixing typical programming
 errors, like style violations, interface misuse, or bugs that can be deduced
 via static analysis. clang-tidy is modular and provides a convenient interface
 for writing new checks.

Package: libclang1-rocm
Section: libs
Architecture: amd64
Depends: ${misc:Depends}, ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Description: C interface to the Clang library
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.
 .
 This package contains the Clang library.
 .
 The C Interface to Clang provides a relatively small API that exposes
 facilities for parsing source code into an abstract syntax tree (AST),
 loading already-parsed ASTs, traversing the AST, associating physical source
 locations with elements within the AST, and other facilities that support
 Clang-based development tools.

Package: libclang-rocm-dev
Architecture: amd64
Section: libdevel
Depends: libclang-common-rocm-dev (= ${binary:Version}),
         libclang1-rocm (= ${binary:Version}),
         ${dep:devlibs-objc},
         ${dep:devlibs},
         ${misc:Depends},
         ${shlibs:Depends}
Description: Clang library - Development package
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.
 .
 This package contains the Clang headers to develop extensions over
 libclang1-rocm.

Package: libclang-common-rocm-dev
Architecture: amd64
Section: libdevel
Depends: ${misc:Depends}, ${shlibs:Depends}
Recommends: libclang-rt-rocm-dev
Description: Clang library - Common development package
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.
 .
 This package contains the Clang generic headers.

# ------------- compiler-rt -------------

Package: libclang-rt-rocm-dev
Architecture: amd64
Section: libdevel
Depends: ${misc:Depends}, ${shlibs:Depends}
Description: Compiler-rt - development package
 This package provides various libraries:
 .
   * builtins - Simple libraries that provide implementation of the
     low-level target-specific hooks required by code generation
     and other runtime components.
   * sanitizer runtimes - AddressSanitizer, ThreadSanitizer,
     UndefinedBehaviorSanitizer, MemorySanitizer, LeakSanitizer
     DataFlowSanitizer, etc
   * profile - Library which is used to collect coverage information.

# ------------- clang libraries -------------

Package: libclang-cpp-rocm
Section: libs
Architecture: amd64
Depends: libllvm-rocm (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Description: C++ interface to the Clang library
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.
 .
 This package contains the Clang C++ library.
 .
 The C++ Interface to Clang provides an API that exposes
 facilities for parsing source code into an abstract syntax tree (AST),
 loading already-parsed ASTs, traversing the AST, associating physical source
 locations with elements within the AST, and other facilities that support
 Clang-based development tools.

Package: libclang-cpp-rocm-dev
Architecture: amd64
Section: libdevel
Depends: libclang-cpp-rocm (= ${binary:Version}),
         ${dep:devlibs},
         ${misc:Depends},
         ${shlibs:Depends}
# Move of libclang-cpp.so into libclang-cpp20.dev
Description: C++ interface to the Clang library
 Clang project is a C, C++, Objective C and Objective C++ front-end
 based on the LLVM compiler. Its goal is to offer a replacement to the
 GNU Compiler Collection (GCC).
 .
 Clang implements all of the ISO C++ 1998, 11, 14 and 17 standards and also
 provides most of the support of C++20.
 .
 This package contains the Clang C++ library.
 .
 The C++ Interface to Clang provides an API that exposes
 facilities for parsing source code into an abstract syntax tree (AST),
 loading already-parsed ASTs, traversing the AST, associating physical source
 locations with elements within the AST, and other facilities that support
 Clang-based development tools.
 .
 This package contains symlinks without a version number, which needed by
 linker at build time.

# ------------- LLVM -------------

Package: libllvm-rocm
Architecture: amd64
Section: libs
Depends: ${misc:Depends}, ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Description: Modular compiler and toolchain technologies, runtime library
 LLVM is a collection of libraries and tools that make it easy to build
 compilers, optimizers, just-in-time code generators, and many other
 compiler-related programs.
 .
 This package contains the LLVM runtime library.

Package: llvm-rocm-linker-tools
Architecture: amd64
Depends: ${misc:Depends}, ${shlibs:Depends}
Description: Modular compiler and toolchain technologies - Plugins
 LLVM is a collection of libraries and tools that make it easy to build
 compilers, optimizers, just-in-time code generators, and many other
 compiler-related programs.
 .
 This package contains the LLVMgold and LLVMPolly linker plugins.

Package: llvm-rocm
Architecture: amd64
Depends: llvm-rocm-linker-tools (= ${binary:Version}),
         llvm-rocm-runtime (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: llvm-rocm-dev
Description: Modular compiler and toolchain technologies
 LLVM is a collection of libraries and tools that make it easy to build
 compilers, optimizers, just-in-time code generators, and many other
 compiler-related programs.
 .
 LLVM uses a single, language-independent virtual instruction set both
 as an offline code representation (to communicate code between
 compiler phases and to run-time systems) and as the compiler internal
 representation (to analyze and transform programs). This persistent
 code representation allows a common set of sophisticated compiler
 techniques to be applied at compile-time, link-time, install-time,
 run-time, or "idle-time" (between program runs).
 .
 The strengths of the LLVM infrastructure are its extremely
 simple design (which makes it easy to understand and use),
 source-language independence, powerful mid-level optimizer, automated
 compiler debugging support, extensibility, and its stability and
 reliability. LLVM is currently being used to host a wide variety of
 academic research projects and commercial projects. LLVM includes C
 and C++ front-ends, a front-end for a Forth-like language (Stacker),
 a young scheme front-end, and Java support is in development. LLVM can
 generate code for X96, SparcV10, PowerPC or many other architectures.

Package: llvm-rocm-runtime
Architecture: amd64
Depends: ${misc:Depends}, ${shlibs:Depends}
Recommends: binfmt-support | systemd
Description: Modular compiler and toolchain technologies, IR interpreter
 LLVM is a collection of libraries and tools that make it easy to build
 compilers, optimizers, just-in-time code generators, and many other
 compiler-related programs.
 .
 LLVM uses a single, language-independent virtual instruction set both
 as an offline code representation (to communicate code between
 compiler phases and to run-time systems) and as the compiler internal
 representation (to analyze and transform programs). This persistent
 code representation allows a common set of sophisticated compiler
 techniques to be applied at compile-time, link-time, install-time,
 run-time, or "idle-time" (between program runs).
 .
 This package provides the minimal required to execute programs in LLVM
 format.

Package: llvm-rocm-dev
Architecture: amd64
Depends: libclang-cpp-rocm (= ${binary:Version}),
         libffi-dev,
         libllvm-rocm (= ${binary:Version}),
         libncurses-dev,
         libxml2-dev,
         libz3-dev [!sh4],
         llvm-rocm (= ${binary:Version}),
         llvm-rocm-tools (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Description: Modular compiler and toolchain technologies, libraries and headers
 LLVM is a collection of libraries and tools that make it easy to build
 compilers, optimizers, just-in-time code generators, and many other
 compiler-related programs.
 .
 LLVM uses a single, language-independent virtual instruction set both
 as an offline code representation (to communicate code between
 compiler phases and to run-time systems) and as the compiler internal
 representation (to analyze and transform programs). This persistent
 code representation allows a common set of sophisticated compiler
 techniques to be applied at compile-time, link-time, install-time,
 run-time, or "idle-time" (between program runs).
 .
 This package provides the libraries and headers to develop applications
 using llvm.

Package: llvm-rocm-tools
Architecture: amd64
Depends: python3,
         python3-pygments,
         python3-yaml,
         ${misc:Depends},
         ${shlibs:Depends}
# Because of yaml-bench
Description: Modular compiler and toolchain technologies, tools
 LLVM is a collection of libraries and tools that make it easy to build
 compilers, optimizers, just-in-time code generators, and many other
 compiler-related programs.
 .
 LLVM uses a single, language-independent virtual instruction set both
 as an offline code representation (to communicate code between
 compiler phases and to run-time systems) and as the compiler internal
 representation (to analyze and transform programs). This persistent
 code representation allows a common set of sophisticated compiler
 techniques to be applied at compile-time, link-time, install-time,
 run-time, or "idle-time" (between program runs).
 .
 This package provides tools for testing.

# ------------- lld -------------

Package: lld-rocm
Architecture: amd64
Depends: libllvm-rocm (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Description: LLVM-based linker
 LLD is a new, high-performance linker. It is built as a set of reusable
 components which highly leverage existing libraries in the larger LLVM
 Project.

Package: liblld-rocm
Architecture: amd64
Depends: libllvm-rocm (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Section: libs
Description: LLVM-based linker, library
 LLD is a new, high-performance linker. It is built as a set of reusable
 components which highly leverage existing libraries in the larger LLVM
 Project.
 .
 This package contains the LLD runtime library.

Package: liblld-rocm-dev
Section: libdevel
Architecture: amd64
Depends: liblld-rocm (= ${binary:Version}),
         libzstd-dev,
         lld-rocm (= ${binary:Version}),
         zlib1g-dev,
         ${misc:Depends},
         ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Description: LLVM-based linker, header files
 LLD is a new, high-performance linker. It is built as a set of reusable
 components which highly leverage existing libraries in the larger LLVM
 Project.
 .
 This package provides the header files to build extension over lld.

# ------------- hipcc -------------

Package: hipcc-rocm
Architecture: amd64
Depends: amd-device-libs-rocm (= ${binary:Version}),
         clang-rocm (= ${binary:Version}),
         clang-tools-rocm (= ${binary:Version}),
         libamdhip64-dev,
         libclang-rt-rocm-dev,
         lld-rocm,
         llvm-rocm,
         rocminfo,
         ${misc:Depends},
         ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Conflicts: hipcc
Description: HIP compiler wrapper
 The Heterogeneous-computing Interface for Portability (HIP) API is a C++
 runtime API and kernel language that lets developers create portable
 applications running in heterogeneous systems, using CPUs and AMD GPUs or
 NVIDIA GPUs from a single source code.
 .
 hipcc is a compiler driver utility that will call clang or nvcc, depending on
 target, and pass the appropriate include and library options for the target
 compiler and HIP infrastructure.

# ------------- device-libs -------------

Package: amd-device-libs-rocm
Architecture: amd64
Section: libdevel
Depends: ${misc:Depends}, ${shlibs:Depends}
Conflicts: rocm-device-libs
Description: ROCm device libraries
 This package contains a set of AMD-specific device-side language runtime
 libraries.
 .
 Specifically:
 .
   * Open Compute library controls (oclc*)
   * Open Compute Math library (ocml)
   * Open Compute Kernel library (ockl)
   * OpenCL built-in library (opencl)
   * HIP built-in library (hip)
   * Heterogeneous Compute built-in library (hc)

# ------------- comgr -------------

Package: libamd-comgr3-rocm
Section: libs
Architecture: amd64
Depends: ${misc:Depends}, ${shlibs:Depends}
Pre-Depends: ${misc:Pre-Depends}
Conflicts: libamd-comgr3
Description: Code Object Manager API libraries
 The Comgr library provides APIs for compiling and inspecting AMDGPU code
 objects.

Package: libamd-comgr-rocm-dev
Architecture: amd64
Section: libdevel
Depends: libamd-comgr3-rocm (= ${binary:Version}),
         ${dep:devlibs-objc},
         ${dep:devlibs},
         ${misc:Depends},
         ${shlibs:Depends}
Conflicts: libamd-comgr-dev
Description: Code Object Manager API libraries (development files)
 The Comgr library provides APIs for compiling and inspecting AMDGPU code
 objects.
 .
 This package provides the development library and header files used for
 developing applications using the Code Object Manager API.
