third_party/waf/waflib/Tools/ifort.py

   1 #! /usr/bin/env python
   2 # encoding: utf-8
   3 # DC 2008
   4 # Thomas Nagy 2016-2018 (ita)
   5
   6 import os, re, traceback
   7 from waflib import Utils, Logs, Errors
   8 from waflib.Tools import fc, fc_config, fc_scan, ar, ccroot
   9 from waflib.Configure import conf
  10 from waflib.TaskGen import after_method, feature
  11
  12 @conf
  13 def find_ifort(conf):
  14         fc = conf.find_program('ifort', var='FC')
  15         conf.get_ifort_version(fc)
  16         conf.env.FC_NAME = 'IFORT'
  17
  18 @conf
  19 def ifort_modifier_win32(self):
  20         v = self.env
  21         v.IFORT_WIN32 = True
  22         v.FCSTLIB_MARKER = ''
  23         v.FCSHLIB_MARKER = ''
  24
  25         v.FCLIB_ST = v.FCSTLIB_ST = '%s.lib'
  26         v.FCLIBPATH_ST = v.STLIBPATH_ST = '/LIBPATH:%s'
  27         v.FCINCPATH_ST = '/I%s'
  28         v.FCDEFINES_ST = '/D%s'
  29
  30         v.fcprogram_PATTERN = v.fcprogram_test_PATTERN = '%s.exe'
  31         v.fcshlib_PATTERN = '%s.dll'
  32         v.fcstlib_PATTERN = v.implib_PATTERN = '%s.lib'
  33
  34         v.FCLNK_TGT_F = '/out:'
  35         v.FC_TGT_F = ['/c', '/o', '']
  36         v.FCFLAGS_fcshlib = ''
  37         v.LINKFLAGS_fcshlib = '/DLL'
  38         v.AR_TGT_F = '/out:'
  39         v.IMPLIB_ST = '/IMPLIB:%s'
  40
  41         v.append_value('LINKFLAGS', '/subsystem:console')
  42         if v.IFORT_MANIFEST:
  43                 v.append_value('LINKFLAGS', ['/MANIFEST'])
  44
  45 @conf
  46 def ifort_modifier_darwin(conf):
  47         fc_config.fortran_modifier_darwin(conf)
  48
  49 @conf
  50 def ifort_modifier_platform(conf):
  51         dest_os = conf.env.DEST_OS or Utils.unversioned_sys_platform()
  52         ifort_modifier_func = getattr(conf, 'ifort_modifier_' + dest_os, None)
  53         if ifort_modifier_func:
  54                 ifort_modifier_func()
  55
  56 @conf
  57 def get_ifort_version(conf, fc):
  58         """
  59         Detects the compiler version and sets ``conf.env.FC_VERSION``
  60         """
  61         version_re = re.compile(r"\bIntel\b.*\bVersion\s*(?P<major>\d*)\.(?P<minor>\d*)",re.I).search
  62         if Utils.is_win32:
  63                 cmd = fc
  64         else:
  65                 cmd = fc + ['-logo']
  66
  67         out, err = fc_config.getoutput(conf, cmd, stdin=False)
  68         match = version_re(out) or version_re(err)
  69         if not match:
  70                 conf.fatal('cannot determine ifort version.')
  71         k = match.groupdict()
  72         conf.env.FC_VERSION = (k['major'], k['minor'])
  73
  74 def configure(conf):
  75         """
  76         Detects the Intel Fortran compilers
  77         """
  78         if Utils.is_win32:
  79                 compiler, version, path, includes, libdirs, arch = conf.detect_ifort()
  80                 v = conf.env
  81                 v.DEST_CPU = arch
  82                 v.PATH = path
  83                 v.INCLUDES = includes
  84                 v.LIBPATH = libdirs
  85                 v.MSVC_COMPILER = compiler
  86                 try:
  87                         v.MSVC_VERSION = float(version)
  88                 except ValueError:
  89                         v.MSVC_VERSION = float(version[:-3])
  90
  91                 conf.find_ifort_win32()
  92                 conf.ifort_modifier_win32()
  93         else:
  94                 conf.find_ifort()
  95                 conf.find_program('xiar', var='AR')
  96                 conf.find_ar()
  97                 conf.fc_flags()
  98                 conf.fc_add_flags()
  99                 conf.ifort_modifier_platform()
 100
 101
 102 all_ifort_platforms = [ ('intel64', 'amd64'), ('em64t', 'amd64'), ('ia32', 'x86'), ('Itanium', 'ia64')]
 103 """List of icl platforms"""
 104
 105 @conf
 106 def gather_ifort_versions(conf, versions):
 107         """
 108         List compiler versions by looking up registry keys
 109         """
 110         version_pattern = re.compile(r'^...?.?\....?.?')
 111         try:
 112                 all_versions = Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Wow6432node\\Intel\\Compilers\\Fortran')
 113         except OSError:
 114                 try:
 115                         all_versions = Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Intel\\Compilers\\Fortran')
 116                 except OSError:
 117                         return
 118         index = 0
 119         while 1:
 120                 try:
 121                         version = Utils.winreg.EnumKey(all_versions, index)
 122                 except OSError:
 123                         break
 124                 index += 1
 125                 if not version_pattern.match(version):
 126                         continue
 127                 targets = {}
 128                 for target,arch in all_ifort_platforms:
 129                         if target=='intel64':
 130                                 targetDir='EM64T_NATIVE'
 131                         else:
 132                                 targetDir=target
 133                         try:
 134                                 Utils.winreg.OpenKey(all_versions,version+'\\'+targetDir)
 135                                 icl_version=Utils.winreg.OpenKey(all_versions,version)
 136                                 path,type=Utils.winreg.QueryValueEx(icl_version,'ProductDir')
 137                         except OSError:
 138                                 pass
 139                         else:
 140                                 batch_file=os.path.join(path,'bin','ifortvars.bat')
 141                                 if os.path.isfile(batch_file):
 142                                         targets[target] = target_compiler(conf, 'intel', arch, version, target, batch_file)
 143
 144                 for target,arch in all_ifort_platforms:
 145                         try:
 146                                 icl_version = Utils.winreg.OpenKey(all_versions, version+'\\'+target)
 147                                 path,type = Utils.winreg.QueryValueEx(icl_version,'ProductDir')
 148                         except OSError:
 149                                 continue
 150                         else:
 151                                 batch_file=os.path.join(path,'bin','ifortvars.bat')
 152                                 if os.path.isfile(batch_file):
 153                                         targets[target] = target_compiler(conf, 'intel', arch, version, target, batch_file)
 154                 major = version[0:2]
 155                 versions['intel ' + major] = targets
 156
 157 @conf
 158 def setup_ifort(conf, versiondict):
 159         """
 160         Checks installed compilers and targets and returns the first combination from the user's
 161         options, env, or the global supported lists that checks.
 162
 163         :param versiondict: dict(platform -> dict(architecture -> configuration))
 164         :type versiondict: dict(string -> dict(string -> target_compiler)
 165         :return: the compiler, revision, path, include dirs, library paths and target architecture
 166         :rtype: tuple of strings
 167         """
 168         platforms = Utils.to_list(conf.env.MSVC_TARGETS) or [i for i,j in all_ifort_platforms]
 169         desired_versions = conf.env.MSVC_VERSIONS or list(reversed(list(versiondict.keys())))
 170         for version in desired_versions:
 171                 try:
 172                         targets = versiondict[version]
 173                 except KeyError:
 174                         continue
 175                 for arch in platforms:
 176                         try:
 177                                 cfg = targets[arch]
 178                         except KeyError:
 179                                 continue
 180                         cfg.evaluate()
 181                         if cfg.is_valid:
 182                                 compiler,revision = version.rsplit(' ', 1)
 183                                 return compiler,revision,cfg.bindirs,cfg.incdirs,cfg.libdirs,cfg.cpu
 184         conf.fatal('ifort: Impossible to find a valid architecture for building %r - %r' % (desired_versions, list(versiondict.keys())))
 185
 186 @conf
 187 def get_ifort_version_win32(conf, compiler, version, target, vcvars):
 188         # FIXME hack
 189         try:
 190                 conf.msvc_cnt += 1
 191         except AttributeError:
 192                 conf.msvc_cnt = 1
 193         batfile = conf.bldnode.make_node('waf-print-msvc-%d.bat' % conf.msvc_cnt)
 194         batfile.write("""@echo off
 195 set INCLUDE=
 196 set LIB=
 197 call "%s" %s
 198 echo PATH=%%PATH%%
 199 echo INCLUDE=%%INCLUDE%%
 200 echo LIB=%%LIB%%;%%LIBPATH%%
 201 """ % (vcvars,target))
 202         sout = conf.cmd_and_log(['cmd.exe', '/E:on', '/V:on', '/C', batfile.abspath()])
 203         batfile.delete()
 204         lines = sout.splitlines()
 205
 206         if not lines[0]:
 207                 lines.pop(0)
 208
 209         MSVC_PATH = MSVC_INCDIR = MSVC_LIBDIR = None
 210         for line in lines:
 211                 if line.startswith('PATH='):
 212                         path = line[5:]
 213                         MSVC_PATH = path.split(';')
 214                 elif line.startswith('INCLUDE='):
 215                         MSVC_INCDIR = [i for i in line[8:].split(';') if i]
 216                 elif line.startswith('LIB='):
 217                         MSVC_LIBDIR = [i for i in line[4:].split(';') if i]
 218         if None in (MSVC_PATH, MSVC_INCDIR, MSVC_LIBDIR):
 219                 conf.fatal('ifort: Could not find a valid architecture for building (get_ifort_version_win32)')
 220
 221         # Check if the compiler is usable at all.
 222         # The detection may return 64-bit versions even on 32-bit systems, and these would fail to run.
 223         env = dict(os.environ)
 224         env.update(PATH = path)
 225         compiler_name, linker_name, lib_name = _get_prog_names(conf, compiler)
 226         fc = conf.find_program(compiler_name, path_list=MSVC_PATH)
 227
 228         # delete CL if exists. because it could contain parameters which can change cl's behaviour rather catastrophically.
 229         if 'CL' in env:
 230                 del(env['CL'])
 231
 232         try:
 233                 conf.cmd_and_log(fc + ['/help'], env=env)
 234         except UnicodeError:
 235                 st = traceback.format_exc()
 236                 if conf.logger:
 237                         conf.logger.error(st)
 238                 conf.fatal('ifort: Unicode error - check the code page?')
 239         except Exception as e:
 240                 Logs.debug('ifort: get_ifort_version: %r %r %r -> failure %s', compiler, version, target, str(e))
 241                 conf.fatal('ifort: cannot run the compiler in get_ifort_version (run with -v to display errors)')
 242         else:
 243                 Logs.debug('ifort: get_ifort_version: %r %r %r -> OK', compiler, version, target)
 244         finally:
 245                 conf.env[compiler_name] = ''
 246
 247         return (MSVC_PATH, MSVC_INCDIR, MSVC_LIBDIR)
 248
 249 class target_compiler(object):
 250         """
 251         Wraps a compiler configuration; call evaluate() to determine
 252         whether the configuration is usable.
 253         """
 254         def __init__(self, ctx, compiler, cpu, version, bat_target, bat, callback=None):
 255                 """
 256                 :param ctx: configuration context to use to eventually get the version environment
 257                 :param compiler: compiler name
 258                 :param cpu: target cpu
 259                 :param version: compiler version number
 260                 :param bat_target: ?
 261                 :param bat: path to the batch file to run
 262                 :param callback: optional function to take the realized environment variables tup and map it (e.g. to combine other constant paths)
 263                 """
 264                 self.conf = ctx
 265                 self.name = None
 266                 self.is_valid = False
 267                 self.is_done = False
 268
 269                 self.compiler = compiler
 270                 self.cpu = cpu
 271                 self.version = version
 272                 self.bat_target = bat_target
 273                 self.bat = bat
 274                 self.callback = callback
 275
 276         def evaluate(self):
 277                 if self.is_done:
 278                         return
 279                 self.is_done = True
 280                 try:
 281                         vs = self.conf.get_ifort_version_win32(self.compiler, self.version, self.bat_target, self.bat)
 282                 except Errors.ConfigurationError:
 283                         self.is_valid = False
 284                         return
 285                 if self.callback:
 286                         vs = self.callback(self, vs)
 287                 self.is_valid = True
 288                 (self.bindirs, self.incdirs, self.libdirs) = vs
 289
 290         def __str__(self):
 291                 return str((self.bindirs, self.incdirs, self.libdirs))
 292
 293         def __repr__(self):
 294                 return repr((self.bindirs, self.incdirs, self.libdirs))
 295
 296 @conf
 297 def detect_ifort(self):
 298         return self.setup_ifort(self.get_ifort_versions(False))
 299
 300 @conf
 301 def get_ifort_versions(self, eval_and_save=True):
 302         """
 303         :return: platforms to compiler configurations
 304         :rtype: dict
 305         """
 306         dct = {}
 307         self.gather_ifort_versions(dct)
 308         return dct
 309
 310 def _get_prog_names(self, compiler):
 311         if compiler=='intel':
 312                 compiler_name = 'ifort'
 313                 linker_name = 'XILINK'
 314                 lib_name = 'XILIB'
 315         else:
 316                 # assumes CL.exe
 317                 compiler_name = 'CL'
 318                 linker_name = 'LINK'
 319                 lib_name = 'LIB'
 320         return compiler_name, linker_name, lib_name
 321
 322 @conf
 323 def find_ifort_win32(conf):
 324         # the autodetection is supposed to be performed before entering in this method
 325         v = conf.env
 326         path = v.PATH
 327         compiler = v.MSVC_COMPILER
 328         version = v.MSVC_VERSION
 329
 330         compiler_name, linker_name, lib_name = _get_prog_names(conf, compiler)
 331         v.IFORT_MANIFEST = (compiler == 'intel' and version >= 11)
 332
 333         # compiler
 334         fc = conf.find_program(compiler_name, var='FC', path_list=path)
 335
 336         # before setting anything, check if the compiler is really intel fortran
 337         env = dict(conf.environ)
 338         if path:
 339                 env.update(PATH = ';'.join(path))
 340         if not conf.cmd_and_log(fc + ['/nologo', '/help'], env=env):
 341                 conf.fatal('not intel fortran compiler could not be identified')
 342
 343         v.FC_NAME = 'IFORT'
 344
 345         if not v.LINK_FC:
 346                 conf.find_program(linker_name, var='LINK_FC', path_list=path, mandatory=True)
 347
 348         if not v.AR:
 349                 conf.find_program(lib_name, path_list=path, var='AR', mandatory=True)
 350                 v.ARFLAGS = ['/nologo']
 351
 352         # manifest tool. Not required for VS 2003 and below. Must have for VS 2005 and later
 353         if v.IFORT_MANIFEST:
 354                 conf.find_program('MT', path_list=path, var='MT')
 355                 v.MTFLAGS = ['/nologo']
 356
 357         try:
 358                 conf.load('winres')
 359         except Errors.WafError:
 360                 Logs.warn('Resource compiler not found. Compiling resource file is disabled')
 361
 362 #######################################################################################################
 363 ##### conf above, build below
 364
 365 @after_method('apply_link')
 366 @feature('fc')
 367 def apply_flags_ifort(self):
 368         """
 369         Adds additional flags implied by msvc, such as subsystems and pdb files::
 370
 371                 def build(bld):
 372                         bld.stlib(source='main.c', target='bar', subsystem='gruik')
 373         """
 374         if not self.env.IFORT_WIN32 or not getattr(self, 'link_task', None):
 375                 return
 376
 377         is_static = isinstance(self.link_task, ccroot.stlink_task)
 378
 379         subsystem = getattr(self, 'subsystem', '')
 380         if subsystem:
 381                 subsystem = '/subsystem:%s' % subsystem
 382                 flags = is_static and 'ARFLAGS' or 'LINKFLAGS'
 383                 self.env.append_value(flags, subsystem)
 384
 385         if not is_static:
 386                 for f in self.env.LINKFLAGS:
 387                         d = f.lower()
 388                         if d[1:] == 'debug':
 389                                 pdbnode = self.link_task.outputs[0].change_ext('.pdb')
 390                                 self.link_task.outputs.append(pdbnode)
 391
 392                                 if getattr(self, 'install_task', None):
 393                                         self.pdb_install_task = self.add_install_files(install_to=self.install_task.install_to, install_from=pdbnode)
 394
 395                                 break
 396
 397 @feature('fcprogram', 'fcshlib', 'fcprogram_test')
 398 @after_method('apply_link')
 399 def apply_manifest_ifort(self):
 400         """
 401         Enables manifest embedding in Fortran DLLs when using ifort on Windows
 402         See: http://msdn2.microsoft.com/en-us/library/ms235542(VS.80).aspx
 403         """
 404         if self.env.IFORT_WIN32 and getattr(self, 'link_task', None):
 405                 # it seems ifort.exe cannot be called for linking
 406                 self.link_task.env.FC = self.env.LINK_FC
 407
 408         if self.env.IFORT_WIN32 and self.env.IFORT_MANIFEST and getattr(self, 'link_task', None):
 409                 out_node = self.link_task.outputs[0]
 410                 man_node = out_node.parent.find_or_declare(out_node.name + '.manifest')
 411                 self.link_task.outputs.append(man_node)
 412                 self.env.DO_MANIFEST = True
 413