spack recipe for amdlibm (#20487)

3 files changed, 698 insertions, 0 deletions

diff --git a/var/spack/repos/builtin/packages/amdlibm/0001-libm-ose-Scripts-cleanup-pyc-files.patch b/var/spack/repos/builtin/packages/amdlibm/0001-libm-ose-Scripts-cleanup-pyc-files.patch
new file mode 100755
index 0000000000..fc084b7d4b
--- /dev/null
+++ b/var/spack/repos/builtin/packages/amdlibm/0001-libm-ose-Scripts-cleanup-pyc-files.patch
@@ -0,0 +1,601 @@
+From edd381260e27226d48108ec7b578c43caf723640 Mon Sep 17 00:00:00 2001
+From: Pranoy Jayaraj <Pranoy.Jayaraj@amd.com>
+Date: Sun, 20 Dec 2020 18:04:38 +0530
+Subject: [PATCH 1/2] libm:ose:Scripts:cleanup pyc files
+
+---
+ SConstruct                       |  29 +++++++-
+ scripts/cfg/__init__.py          |  59 ++++++++---------
+ scripts/cfg/compiler/__init__.py | 109 ++++++++++++++-----------------
+ scripts/cfg/compiler/gcc.py      | 105 +++++++++++++++--------------
+ scripts/cfg/compiler/llvm.py     |  57 ++++++++++++----
+ scripts/cfg/helper.py            |  14 ++++
+ src/SConscript                   |   3 +
+ 7 files changed, 220 insertions(+), 156 deletions(-)
+
+diff --git a/SConstruct b/SConstruct
+index 79a7695..64150c0 100644
+--- a/SConstruct
++++ b/SConstruct
+@@ -53,6 +53,22 @@ defcfg = DefaultCfg(build_root=Dir('#build', create=True))
+ 
+ env = defcfg.GetDefaultEnv()
+ 
++#check intel lib path
++intel_lib_path = None
++libabi = env['libabi']
++if libabi == 'svml':
++    for p in env['ENV']['PATH'].split(':'):
++        if 'intel' in p:
++            intel_lib_path=p
++            break
++
++    if intel_lib_path is None:
++        print ("Error! Intel lib not found")
++        Exit(2)
++    else:
++        print (intel_lib_path)
++        env.Append(INTEL_LIB_PATH = intel_lib_path)
++
+ # Add shared top-level headers
+ env.Prepend(CPPPATH=[Dir('include')])
+ 
+@@ -98,10 +114,17 @@ targets += amdlibm
+ #
+ # Build Test lib and associated tests
+ #
++
+ testenv = env.Clone()
+-testenv.Append(
+-	LIBPATH=['#'+joinpath(build_root,'src')]
+-)
++if libabi == 'svml':
++    testenv.Append(
++	    LIBPATH=['#'+joinpath(build_root,'src'), env['INTEL_LIB_PATH']]
++    )
++else:
++    testenv.Append(
++        LIBPATH=['#'+joinpath(build_root,'src')]
++    )
++
+ test_lib_objs = []  			# Will fill at a later date
+ test_objs = SConscript(dirs='tests',
+                        exports = {'env' : testenv},
+diff --git a/scripts/cfg/__init__.py b/scripts/cfg/__init__.py
+index d4f34eb..b21ed2f 100644
+--- a/scripts/cfg/__init__.py
++++ b/scripts/cfg/__init__.py
+@@ -1,28 +1,7 @@
++# Copyright (C) Prem Mallappa
+ #
+-# Copyright (C) 2008-2020 Advanced Micro Devices, Inc. All rights reserved.
++# Author: Prem Mallappa <prem.mallappa@gmail.com>
+ #
+-# Redistribution and use in source and binary forms, with or without modification,
+-# are permitted provided that the following conditions are met:
+-# 1. Redistributions of source code must retain the above copyright notice,
+-#    this list of conditions and the following disclaimer.
+-# 2. Redistributions in binary form must reproduce the above copyright notice,
+-#    this list of conditions and the following disclaimer in the documentation
+-#    and/or other materials provided with the distribution.
+-# 3. Neither the name of the copyright holder nor the names of its contributors
+-#    may be used to endorse or promote products derived from this software without
+-#    specific prior written permission.
+-#
+-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+-# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+-# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+-# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+-# POSSIBILITY OF SUCH DAMAGE.
+-
+ from os.path import join as joinpath
+ from os import environ
+ 
+@@ -66,7 +45,9 @@ class DefaultCfg(object):
+         self.defenv = Environment(variables = self.defvars,
+                                   ENV = {'PATH' : environ['PATH']})
+ 
+-        self.Check()
++        #self.Check()
++        #for key in self.defvars.keys():
++        #    print(key)
+ 
+     def AddOptions(self):
+         opts = cfg.LocalOption()
+@@ -119,6 +100,13 @@ class DefaultCfg(object):
+                  --toolchain-base=/usr/local/toolchain/
+                  CC will be used as /usr/local/toolchain/bin/gcc if --compiler is gcc""")
+ 
++        opts.Add('--prefix', dest='prefix', nargs=1, action='callback',
++                 type='str',
++                 callback=self.__default_store,
++                 help="""Specify an install prefix directory
++                 the directory will be create if non-existant""")
++
++
+         self.opts = opts
+ 
+     def AddVariables(self):
+@@ -130,7 +118,7 @@ class DefaultCfg(object):
+                          map={}, ignorecase=0),  # case sensitive
+ 	        # test abi makes tests to call out for given library call
+             EnumVariable('libabi', 'Test ABI for library function calling', 'aocl',
+-                         allowed_values=('aocl', 'glibc', 'libm', 'acml','amdlibm'),
++                         allowed_values=('aocl', 'glibc', 'libm', 'acml','amdlibm', 'svml'),
+                          map={}, ignorecase=2),  # lowercase always
+             EnumVariable('developer', 'A developer friendly mode', 0,
+                          allowed_values=('0', '1', '2', '3', '4'),
+@@ -140,9 +128,15 @@ class DefaultCfg(object):
+             EnumVariable('compiler', "Select compiler type", 'gcc',
+                          allowed_values=('gcc', 'aocc', 'llvm', 'icc'), ignorecase=2),
+ 
+-            PathVariable('toolchain_base', "Use this as toolchain prefix", '/usr/bin')
++            PathVariable('toolchain_base', "Use this as toolchain prefix", '/usr/bin'),
++            PathVariable('prefix', "use this as install prefix", '/usr/local')
+         )
+ 
++        defvars.Add(PathVariable('CC', help="Custome C compiler", default=None, 
++                                validator=PathVariable.PathAccept))
++        defvars.Add(PathVariable('CXX', help="Custome C++ compiler", default=None,
++                                validator=PathVariable.PathAccept))
++
+         self.defvars = defvars
+ 
+     def Check(self):
+@@ -154,7 +148,7 @@ class DefaultCfg(object):
+ 
+         unknown = self.defvars.UnknownVariables()
+         if unknown:
+-            print("Unknown variables:", unknown.keys())
++            print("ALM: build: Unknown variables:", unknown.keys())
+             #Exit(1)
+ 
+         #if debug_mode is mentioned assume build type debug
+@@ -175,14 +169,15 @@ class DefaultCfg(object):
+         env.Append(
+             CPPDEFINES = { 'LIBABI': env['libabi']})
+ 
+-        cmpiler = compiler.gcc.Gcc(self.defenv['build'])
++        cmpiler = compiler.gcc.Gcc(self.defenv['build'],
++                                  bvars=self.defvars, 
++                                  opts=self.opts)
+         #print(env['compiler'])
+         if env['compiler'] == 'aocc' or env['compiler'] == 'llvm':
+             cmpiler = compiler.llvm.LLVM(self.defenv['build'])
+ 
+         env.Replace(
+-            CXX = cmpiler.CXXCmd(),
+-            CC = cmpiler.CCCmd(),
++            CC = cmpiler.Cmd(),
+             CCFLAGS = cmpiler.CFlags(),
+             LINKFLAGS = cmpiler.LDFlags(),
+         )
+@@ -201,6 +196,10 @@ class DefaultCfg(object):
+                 CPPDEFINES = {'DEVELOPER' : env['developer']})
+ 
+         self.defvars.Save(self.def_env_file, env)
++        self.Check()
++
++        env['ENV'].update(environ)
++
+         return env
+ 
+     def GetHelpTexts(self):
+diff --git a/scripts/cfg/compiler/__init__.py b/scripts/cfg/compiler/__init__.py
+index 60e136a..4383d01 100644
+--- a/scripts/cfg/compiler/__init__.py
++++ b/scripts/cfg/compiler/__init__.py
+@@ -23,77 +23,64 @@
+ # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ # POSSIBILITY OF SUCH DAMAGE.
+ 
+-class Compiler:
+-    def init_env(self):
+-        self.env_modifiers = {
+-            'CC'          : '',
+-            'CXX'         : '',
+-            'CPPFLAGS'    : [],
+-            'CFLAGS'      : [],
+-            'CXXFLAGS'    : [],
+-            'CPPDEFINES'  : [],
+-            'LDFLAGS'     : []
+-        }
++import os
+ 
+-    def CCCmd(self):
+-        return self.env_modifiers['CC']
+-
+-    def CXXCmd(self):
+-        return self.env_modifiers['CXX']
++class Compiler:
++    def __init__(self, prod_mode, bvars = None, opts = None):
++        self.vars = bvars
++        self.opts = opts
++        self.cxxcmd = ''
++        self.cmd = ''
++        self.prod_mode = prod_mode
++        self.compile_flags_debug = [
++            '-g',
++            '-Og',
++            '-march=native',
++        ]
++        self.compile_flags_release = [
++            '-Ofast',
++            '-march=native',
++            '-fipa-pta',
++            '-funsafe-loop-optimizations',
++            '-flto=4',
++        ]
++        self.compile_flag_map = {
++			'debug': self.compile_flags_debug,
++			'release' : self.compile_flags_release
++		}
+ 
+-    def CFlags(self):
+-        return self.env_modifiers['CFLAGS']
++        self.link_flags_debug = []
+ 
+-    def LDFlags(self):
+-        return self.env_modifiers['LDFLAGS']
++        self.link_flags_release = self.compile_flags_release
+ 
+-    def Append(self, d):
+-        for key,value in d.items():
+-            if isinstance(self.env_modifiers[key], list):
+-                self.env_modifiers[key].extend(value)
+-            else:
+-                self.env_modifiers[key] = value
++        self.link_flag_map = {
++            "debug": self.link_flags_debug,
++            "release": self.link_flags_release
++        }
+ 
+-    def Replace(self, d):
+-        self.env_modifiers.update(d)
++        self.cpp_flags_debug = []
+ 
+-    def __init__(self, prod_mode):
+-        self.prod_mode = prod_mode
+-        self.init_env()
++        self.cpp_flags_release = []
+ 
+-        compile_flags_debug = [
+-            '-g',
+-            '-Og',
+-            #'-march=native',
+-        ]
++        self.cpp_flag_map = {
++            "debug": self.cpp_flags_debug,
++            "release": self.cpp_flags_release
++        }
+ 
+-        compile_flags_release = [
+-            #'-Ofast',
+-            #'-march=native',
+-            #'-fipa-pta',
+-            #'-funsafe-loop-optimizations',
+-            #'-flto=4',
+-            #'-fno-strict-aliasing',
+-        ]
++    def fixup_from_vars(self):
++        pass
+ 
+-        link_flags_debug = []
+-        link_flags_release = compile_flags_release
++    def fixup_from_env(self):
++        if 'CC' in os.environ:
++            self.cmd = os.getenv('CC')
++        
++        if 'CXX' in os.environ:
++            self.cxxcmd = os.getenv('CXX')
+ 
+-        cpp_flags_debug = []
+-        cpp_flags_release = []
++        if 'CFLAGS' in os.environ:
++            self.compile_flag_map[self.prod_mode]
+ 
+-        pmode = prod_mode.lower()
++        if 'LDFLAGS' in os.environ:
++            self.link_flag_map[self.prod_mode]
+ 
+-        if pmode == "debug" :
+-            self.Append({
+-                'CFLAGS'  : compile_flags_debug,
+-                'LDFLAGS' : link_flags_debug,
+-                'CPPFLAGS': cpp_flags_debug,}
+-            )
+-        elif pmode == "release":
+-            self.Append({
+-                    'CFLAGS'  : compile_flags_release,
+-                    'LDFLAGS' : link_flags_release,
+-                    'CPPFLAGS': cpp_flags_release,}
+-            )
+ 
+diff --git a/scripts/cfg/compiler/gcc.py b/scripts/cfg/compiler/gcc.py
+index c2f8c8e..eb89a73 100644
+--- a/scripts/cfg/compiler/gcc.py
++++ b/scripts/cfg/compiler/gcc.py
+@@ -25,18 +25,36 @@
+ 
+ from . import Compiler
+ class Gcc(Compiler):
+-    def __init__(self, prod_mode):
+-        super(Gcc, self).__init__(prod_mode)
+-
+-        warnings_cxx  = [
+-            '-Wctor-dtor-privacy',
+-            '-Wnoexcept',
+-            '-Wstrict-null-sentinel',
+-            '-Wold-style-cast',
+-            '-Woverloaded-virtual',
++    def __init__(self, prod_mode, bvars = None, opts = None):
++        super(Gcc, self).__init__(prod_mode, bvars, opts)
++        self.cmd = 'gcc'
++        self.cxxcmd = 'g++'
++        self.compile_flags_debug = [
++            '-g',
++            '-Og',
++            '-march=native',
+         ]
++        self.compile_flags_release = []
++        self.compile_flag_map = {
++            'debug': self.compile_flags_debug,
++            'release' : self.compile_flags_release
++        }
++
++        self.link_flags_debug = []
++        self.link_flags_release = self.compile_flags_release
++        self.link_flag_map = {
++            "debug": self.link_flags_debug,
++            "release": self.link_flags_release
++        }
++        self.cpp_flag_map = {
++            "debug":   self.cpp_flags_debug,
++            "release": self.cpp_flags_release
++        }
+ 
+-        warnings_c = [
++        self.cpp_flags_debug = []
++        self.cpp_flags_release = []
++
++        self.warnings = [
+             '-Wall',
+             '-Wextra',
+             '-Wpedantic',
+@@ -44,6 +62,7 @@ class Gcc(Compiler):
+             '-Wcast-align',
+             '-Wcast-qual',
+             '-Wconversion',
++            '-Wctor-dtor-privacy',
+             '-Wdisabled-optimization',
+             '-Wdouble-promotion',
+             #   '-Weffc++',
+@@ -54,7 +73,10 @@ class Gcc(Compiler):
+             #   '-Wlogical-op',
+             '-Wmissing-declarations',
+             '-Wmissing-include-dirs',
++            '-Wnoexcept',
+             '-Wodr',
++            '-Wold-style-cast',
++            '-Woverloaded-virtual',
+             #   '-Wpadded',
+             '-Wredundant-decls',
+             '-Wshadow',
+@@ -62,53 +84,40 @@ class Gcc(Compiler):
+             #   '-Wsign-promo',
+             #   '-Wsuggest-final-methods',
+             #   '-Wsuggest-final-types',
+-            '-fno-strict-aliasing',
+-            # '-Wstrict-overflow=5',
+-            # '-Wswitch-default',
+-            # -Wswitch-enum needs every switch statement to be handled
+-            #       explicitly. It would be useful if the language had some
+-            #       mechanism to activate this on specified switch statements
+-            #       (to ensure that future changes to the enum are handled
+-            #       everywhere that they need to be), but it's overkill for an
+-            #       "all-or-nothing" setting. '-Wswitch-enum',
++            '-Wstrict-null-sentinel',
++            #   '-Wstrict-overflow=5',
++            '-Wswitch-default',
++            # -Wswitch-enum needs every switch statement to be handled explicitly.
++            #       It would be useful if the language had some mechanism
++            #       to activate this on specified switch statements (to ensure that future
++            #       changes to the enum are handled everywhere that they need to be), but it's
++            #       overkill for an "all-or-nothing" setting.
++            #   '-Wswitch-enum',
+             '-Wtrampolines',
+-            # '-Wundef',
+-            # -Wunsafe-loop-optimizations causes too many spurious warnings. It
+-            #       may be useful to apply this one periodically and manually
+-            #       verify the results. It is also issued warning for the
+-            #       constructor of a const array of const std::string (where
+-            #       there is no loop in user code).
++            '-Wundef',
++            # -Wunsafe-loop-optimizations causes too many spurious warnings. It may be
++            #       useful to apply this one periodically and manually verify the results.
++            #       It is also issued warning for the constructor of a const array of const
++            #       std::string (where there is no loop in user code).
+             #
+             #   '-Wunsafe-loop-optimizations',
+             # -Wuseless-cast is incompatible with BOUNDED_INTEGER_CONDITIONAL
+             #   '-Wuseless-cast',
+             '-Wvector-operation-performance',
+-            # -Wzero-as-null-pointer-constant does not work with the
+-            #   operator<=> emulation '-Wzero-as-null-pointer-constant',
++            # -Wzero-as-null-pointer-constant does not work with the operator<=> emulation
++            #   '-Wzero-as-null-pointer-constant',
+             '-Werror',
+             '-Wlto-type-mismatch',
+         ]
++        self.fixup_from_env()
+ 
+ 
+-        # Eventually we should enable all warnings
+-        # with compile_flags_release = [] + warnings_c
+-        compile_flags_release = []
+-        compile_flags_debug   = []
+-
+-        self.Replace({
+-            'CC' : 'gcc',
+-            'CXX': 'g++',
+-        }
+-        )
+-
+-        if self.prod_mode == "debug":
+-            self.Append({
+-                'CFLAGS' : compile_flags_debug,
+-                'CXXFLAGS': warnings_cxx ,                
+-            })
+-        else:
+-            self.Append({
+-                'CFLAGS' : compile_flags_release,
+-                'CXXFLAGS': warnings_cxx,
+-            })
++    def Cmd(self):
++        return self.cmd
++    def CxxCmd(self):
++        return self.cxxcmd
++    def CFlags(self):
++        return self.compile_flag_map[self.prod_mode]
++    def LDFlags(self):
++        return self.link_flag_map[self.prod_mode]
+ 
+diff --git a/scripts/cfg/compiler/llvm.py b/scripts/cfg/compiler/llvm.py
+index 0e4c346..b39d341 100644
+--- a/scripts/cfg/compiler/llvm.py
++++ b/scripts/cfg/compiler/llvm.py
+@@ -26,29 +26,58 @@
+ from . import Compiler
+ 
+ class LLVM(Compiler):
+-    def __init__(self, prod_mode):
+-        super(LLVM, self).__init__(prod_mode)
+-
+-        compile_flags_release = [
+-            # fp-contract needed to generate FMA instructions
+-            '-ffp-contract=fast',
++    def __init__(self, prod_mode, bvars = None, opts = None):
++        super(LLVM, self).__init__(prod_mode, bvars, opts)
++        self.cmd = 'clang'
++        self.cxxcmd = 'clang++'
++        self.compile_flags_debug = [
++            '-g',
++            '-Og',
++            '-march=native',
++        ]
++        self.compile_flags_release = [
++            '-ffp-contract=fast', # Needed to generate FMA instructions for vector routines
+             #'-Ofast',
+             # '-march=native',
+             # '-fipa-pta',
+             # '-funsafe-loop-optimizations',
+             # '-flto=4',
+         ]
++        self.compile_flag_map = {
++            'debug': self.compile_flags_debug,
++            'release' : self.compile_flags_release
++        }
+ 
+-        link_flags_debug = ['-fuse-ld=ld']
+-        link_flags_release = ['-fuse-ld=ld']
++        self.link_flags_debug = ['-fuse-ld=ld']
++        self.link_flags_release = ['-fuse-ld=ld']
++
++        self.link_flag_map = {
++            "debug": self.link_flags_debug,
++            "release": self.link_flags_release
++        }
+ 
+-        llvm = {
+-            'CC'      : 'clang',
+-            'CXX'     : 'clang++',
+-            'CFLAGS'  : link_flags_release,
+-            'LDFLAGS' : link_flags_release
++        self.cpp_flag_map = {
++            "debug":   self.cpp_flags_debug,
++            "release": self.cpp_flags_release
+         }
+ 
+-        self.Append(llvm)
++        self.cpp_flags_debug = []
++        self.cpp_flags_release = []
++
++        self.warnings = [
++            '-Weverything',
++        ]
++
++        self.fixup_from_env()
++
++    def Cmd(self):
++        return self.cmd
++
++    def CxxCmd(self):
++        return self.cxxcmd
+ 
++    def CFlags(self):
++        return self.compile_flag_map[self.prod_mode]
+ 
++    def LDFlags(self):
++        return self.link_flag_map[self.prod_mode]
+diff --git a/scripts/cfg/helper.py b/scripts/cfg/helper.py
+index a0fb991..1d7a01d 100644
+--- a/scripts/cfg/helper.py
++++ b/scripts/cfg/helper.py
+@@ -140,6 +140,18 @@ def UpdateEnvComStr(env):
+         env["SHCCCOMSTR"]   = Transform('SHCC')
+         env["SHLINKCOMSTR"] = Transform('SHLINK', hidesrc=True)
+ 
++
++def MakeInstallRoot(env):
++    """Build root has
++       build/<libabi>-<debug/release/developer>
++    """
++    try:
++        inst = env['prefix']
++    except KeyError:
++        inst = '#install'
++
++    env['INSTALL_PREFIX'] = inst
++
+ def MakeBuildRoot(env):
+     """Build root has
+        build/<libabi>-<debug/release/developer>
+@@ -178,7 +190,9 @@ def SetupConfiguration(env):
+         and puts target into testdir."""
+         #print(env.Dump())
+         MakeBuildRoot(env)
++        MakeInstallRoot(env)
+         UpdateEnvComStr(env)
++        env['compiler'] = GetOption('compiler')
+ 
+         if env['debug_mode'] != 'no':
+             env.Append(CPPDEFINES = {'DEBUG': '1'})
+diff --git a/src/SConscript b/src/SConscript
+index 0fe4e19..32d6b83 100644
+--- a/src/SConscript
++++ b/src/SConscript
+@@ -27,6 +27,7 @@
+ Import('env')
+ from os.path import join as joinpath
+ 
++installdir = env['prefix']
+ builddir = joinpath(env['BUILDROOT'], 'src')
+ 
+ e = env.Clone()
+@@ -73,6 +74,8 @@ libm = almenv.StaticLibrary('alm', alm_objs)
+ libmso = almenv.SharedLibrary('alm', alm_objs)
+ 
+ 
++almenv.Alias("install", almenv.Install(joinpath(installdir, "lib"), [libmso, libm]))
++
+ fast_libm = SConscript('fast/SConscript',
+                        exports = {'env' : e},
+                        duplicate = 0,
+-- 
+2.28.0
+
diff --git a/var/spack/repos/builtin/packages/amdlibm/0002-libm-ose-prevent-log-v3.c-from-building.patch b/var/spack/repos/builtin/packages/amdlibm/0002-libm-ose-prevent-log-v3.c-from-building.patch
new file mode 100755
index 0000000000..b540f1cda3
--- /dev/null
+++ b/var/spack/repos/builtin/packages/amdlibm/0002-libm-ose-prevent-log-v3.c-from-building.patch
@@ -0,0 +1,25 @@
+From 5ade2f2eb1745f1d09281044e44b3272f01eb5ed Mon Sep 17 00:00:00 2001
+From: Prem Mallappa <Premachandra.Mallappa@amd.com>
+Date: Tue, 22 Dec 2020 21:03:57 +0530
+Subject: [PATCH 2/2] libm: ose: prevent log-v3.c from building
+
+Signed-off-by: Prem Mallappa <Premachandra.Mallappa@amd.com>
+---
+ src/optmized/SConscript | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/src/optmized/SConscript b/src/optmized/SConscript
+index a614e9b..412dbdf 100644
+--- a/src/optmized/SConscript
++++ b/src/optmized/SConscript
+@@ -67,6 +67,7 @@ else:
+ 
+ experiment_src=[
+ 	'expm1f.c',
++        'log_v3.c',
+ 	]
+ 
+ source = Glob('*.c', exclude=experiment_src)
+-- 
+2.28.0
+
diff --git a/var/spack/repos/builtin/packages/amdlibm/package.py b/var/spack/repos/builtin/packages/amdlibm/package.py
new file mode 100644
index 0000000000..f00b8cb968
--- /dev/null
+++ b/var/spack/repos/builtin/packages/amdlibm/package.py
@@ -0,0 +1,72 @@
+# Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack import *
+import os
+
+
+class Amdlibm(SConsPackage):
+    """AMD LibM is a software library containing a collection of basic math
+    functions optimized for x86-64 processor-based machines. It provides
+    many routines from the list of standard C99 math functions.
+    Applications can link into AMD LibM library and invoke math functions
+    instead of compiler's math functions for better accuracy and
+    performance."""
+
+    homepage = "https://developer.amd.com/amd-aocl/amd-math-library-libm/"
+    git = "https://github.com/amd/aocl-libm-ose.git"
+    maintainers = ["amd-toolchain-support"]
+
+    # If a user who doesn't specify a version
+    # amdlibm installed for commit ID:4033e02
+    # of master branch.
+    # To install amdlibm from latest master branch:
+    # spack install amdlibm ^amdlibm@master
+    version("master", branch="master")
+    version("20201104",
+            commit="4033e022da428125747e118ccd6fdd9cee21c470",
+            preferred=True)
+
+    variant("verbose", default=False,
+            description="Building with verbosity")
+
+    # Mandatory dependencies
+    depends_on("python@3.6.1:", type=("build", "run"))
+    depends_on("scons@3.1.2:", type=("build"))
+    depends_on("mpfr", type=("link"))
+
+    patch('0001-libm-ose-Scripts-cleanup-pyc-files.patch')
+    patch('0002-libm-ose-prevent-log-v3.c-from-building.patch')
+
+    conflicts("%gcc@:9.1.999", msg="Minimum required GCC version is 9.2.0")
+
+    def build_args(self, spec, prefix):
+        """Setting build arguments for amdlibm """
+        args = ["--prefix={0}".format(prefix)]
+
+        if "%aocc" in spec:
+            args.append("--compiler=aocc")
+
+        # we are circumventing the use of
+        # Spacks compiler wrappers because
+        # SCons wipes out all environment variables.
+        args.append("CC={0}".format(self.compiler.cc))
+        args.append("CXX={0}".format(self.compiler.cxx))
+
+        if "+verbose" in spec:
+            args.append("verbose=1")
+        else:
+            args.append("verbose=0")
+
+        return args
+
+    install_args = build_args
+
+    @run_after('install')
+    def create_symlink(self):
+        """Symbolic link for backward compatibility"""
+        with working_dir(self.prefix.lib):
+            os.symlink('libalm.a', 'libamdlibm.a')
+            os.symlink('libalm.so', 'libamdlibm.so')