Source code for ToolChain.GHDL

# EMACS settings: -*-	tab-width: 2; indent-tabs-mode: t; python-indent-offset: 2 -*-
# vim: tabstop=2:shiftwidth=2:noexpandtab
# kate: tab-width 2; replace-tabs off; indent-width 2;
#
# ==============================================================================
# Authors:          Patrick Lehmann
#                   Martin Zabel
#                   Thomas B. Preusser
#
# Python Class:     GHDL specific classes
#
# License:
# ==============================================================================
# Copyright 2007-2016 Technische Universitaet Dresden - Germany
#                     Chair of VLSI-Design, Diagnostics and Architecture
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
#
# load dependencies
from pathlib                import Path
from re                     import compile as re_compile
from subprocess             import check_output, CalledProcessError

from lib.Functions          import CallByRefParam, Init
from Base.Exceptions        import PlatformNotSupportedException
from Base.Logging           import LogEntry, Severity
from Base.Executable        import LongValuedFlagArgument, DryRunException
from Base.Executable        import ExecutableArgument, PathArgument, StringArgument, ValuedFlagListArgument
from Base.Executable        import ShortFlagArgument, LongFlagArgument, CommandLineArgumentList
from DataBase.Entity        import SimulationResult
from ToolChain              import ToolMixIn, ToolChainException, ConfigurationException, ToolConfiguration, OutputFilteredExecutable
from Simulator              import PoCSimulationResultFilter


__api__ = [
	'GHDLException',
	'GHDLReanalyzeException',
	'Configuration',
	'GHDL',
	'GHDLAnalyze',
	'GHDLElaborate',
	'GHDLRun',
	'GHDLAnalyzeFilter',
	'GHDLElaborateFilter',
	'GHDLRunFilter'
]
__all__ = __api__


[docs]class GHDLException(ToolChainException): pass
[docs]class GHDLReanalyzeException(GHDLException): pass
[docs]class Configuration(ToolConfiguration): _vendor = "tgingold" #: The name of the tools vendor. _toolName = "GHDL" #: The name of the tool. _section = "INSTALL.GHDL" #: The name of the configuration section. Pattern: ``INSTALL.Vendor.ToolName``. _multiVersionSupport = True #: Git supports multiple versions installed on the same system. _template = { "Windows": { _section: { "Version": "0.34-dev", "Backend": "mcode", "Runtime": "gnatgpl32", "SectionName": ("%{PathWithRoot}#${Version}-${Runtime}-${Backend}", None), "InstallationDirectory": ("${${SectionName}:InstallationDirectory}", "C:/Tools/GHDL/${Version}-${Runtime}-${Backend}"), "BinaryDirectory": ("${${SectionName}:BinaryDirectory}", "${InstallationDirectory}/bin"), "ScriptDirectory": ("${${SectionName}:ScriptDirectory}", "${InstallationDirectory}/lib/vendors") } }, "Linux": { _section: { "Version": "0.34-dev", "Backend": "llvm", "SectionName": ("%{PathWithRoot}#${Version}-${Backend}", None), "InstallationDirectory": ("${${SectionName}:InstallationDirectory}", "/usr/local"), "BinaryDirectory": ("${${SectionName}:BinaryDirectory}", "${InstallationDirectory}/bin"), "ScriptDirectory": ("${${SectionName}:ScriptDirectory}", "${InstallationDirectory}/lib/ghdl/vendors") } }, "Darwin": { _section: { "Version": "0.34-dev", "Backend": "llvm", "SectionName": ("%{PathWithRoot}#${Version}-${Backend}", None), "InstallationDirectory": ("${${SectionName}:InstallationDirectory}", "/usr/local"), "BinaryDirectory": ("${${SectionName}:BinaryDirectory}", "${InstallationDirectory}/bin"), "ScriptDirectory": ("${${SectionName}:ScriptDirectory}", "${InstallationDirectory}/lib/ghdl/vendors") } } } #: The template for the configuration sections represented as nested dictionaries.
[docs] def ConfigureForAll(self): try: if (not self._AskInstalled("Is GHDL installed on your system?")): self.ClearSection() else: # Configure GHDL version if self._multiVersionSupport: self.PrepareVersionedSections() self._ConfigureInstallationDirectory() binPath = self._ConfigureBinaryDirectory() self.__WriteGHDLSection(binPath) self._host.LogNormal("{DARK_GREEN}GHDL is now configured.{NOCOLOR}".format(**Init.Foreground), indent=1) except ConfigurationException: self.ClearSection() raise
[docs] def _GetDefaultInstallationDirectory(self): if (self._host.Platform in ["Linux", "Darwin"]): try: name = check_output(["which", "ghdl"], universal_newlines=True).strip() if name != "": return Path(name).parent.as_posix() except CalledProcessError: pass # `which` returns non-zero exit code if GHDL is not in PATH return super()._GetDefaultInstallationDirectory()
[docs] def _ConfigureBinaryDirectory(self): """Updates section with value from _template and returns directory as Path object.""" self._ConfigureScriptDirectory() return super()._ConfigureBinaryDirectory()
[docs] def _ConfigureScriptDirectory(self): """Updates section with value from _template and returns directory as Path object.""" # unresolved = self._template[self._host.Platform][self._section]['ScriptDirectory'] # self._host.PoCConfig[self._section]['ScriptDirectory'] = unresolved # create entry scriptPath = Path(self._host.PoCConfig[self._section]['ScriptDirectory']) # resolve entry if (not scriptPath.exists()): raise ConfigurationException("{0!s} script directory '{1!s}' does not exist.".format(self, scriptPath)) \ from NotADirectoryError(str(scriptPath))
def __WriteGHDLSection(self, binPath): if (self._host.Platform == "Windows"): ghdlPath = binPath / "ghdl.exe" else: ghdlPath = binPath / "ghdl" if not ghdlPath.exists(): raise ConfigurationException("Executable '{0!s}' not found.".format(ghdlPath)) from FileNotFoundError( str(ghdlPath)) # get version and backend output = check_output([str(ghdlPath), "-v"], universal_newlines=True) version = None backend = None versionRegExpStr = r"^GHDL (.+?) " versionRegExp = re_compile(versionRegExpStr) backendRegExpStr = r"(?i).*(mcode|gcc|llvm).* code generator" backendRegExp = re_compile(backendRegExpStr) for line in output.split('\n'): if version is None: match = versionRegExp.match(line) if match is not None: version = match.group(1) if backend is None: match = backendRegExp.match(line) if match is not None: backend = match.group(1).lower() if ((version is None) or (backend is None)): raise ConfigurationException("Version number or back-end name not found in '{0!s} -v' output.".format(ghdlPath)) self._host.PoCConfig[self._section]['Version'] = version self._host.PoCConfig[self._section]['Backend'] = backend
[docs]class GHDL(OutputFilteredExecutable, ToolMixIn): def __init__(self, platform, dryrun, binaryDirectoryPath, version, backend, logger=None): ToolMixIn.__init__(self, platform, dryrun, binaryDirectoryPath, version, logger=logger) if (platform == "Windows"): executablePath = binaryDirectoryPath / "ghdl.exe" elif (platform == "Linux"): executablePath = binaryDirectoryPath / "ghdl" elif (platform == "Darwin"): executablePath = binaryDirectoryPath / "ghdl" else: raise PlatformNotSupportedException(platform) super().__init__(platform, dryrun, executablePath, logger=logger) self.Executable = executablePath #self.Parameters[self.Executable] = executablePath if (platform == "Windows"): if (backend not in ["llvm", "mcode"]): raise GHDLException("GHDL for Windows does not support backend '{0}'.".format(backend)) elif (platform == "Linux"): if (backend not in ["gcc", "llvm", "mcode"]): raise GHDLException("GHDL for Linux does not support backend '{0}'.".format(backend)) elif (platform == "Darwin"): if (backend not in ["gcc", "llvm", "mcode"]): raise GHDLException("GHDL for OS X does not support backend '{0}'.".format(backend)) self._binaryDirectoryPath = binaryDirectoryPath self._backend = backend self._version = version @property def BinaryDirectoryPath(self): return self._binaryDirectoryPath @property def Backend(self): return self._backend @property def Version(self): return self._version
[docs] def deco(Arg): def getter(_): return Arg.Value def setter(_, value): Arg.Value = value return property(getter, setter)
Executable = deco(ExecutableArgument("Executable", (), {})) #class Executable(metaclass=ExecutableArgument): # pass
[docs] class CmdAnalyze(metaclass=ShortFlagArgument): _name = "a"
[docs] class CmdElaborate(metaclass=ShortFlagArgument): _name = "e"
[docs] class CmdRun(metaclass=ShortFlagArgument): _name = "r"
[docs] class FlagVerbose(metaclass=ShortFlagArgument): _name = "v"
[docs] class FlagDebug(metaclass=ShortFlagArgument): _name = "g"
[docs] class FlagExplicit(metaclass=ShortFlagArgument): _name = "fexplicit"
[docs] class FlagRelaxedRules(metaclass=ShortFlagArgument): _name = "frelaxed-rules"
[docs] class FlagWarnBinding(metaclass=LongFlagArgument): _name = "warn-binding"
[docs] class FlagNoVitalChecks(metaclass=LongFlagArgument): _name = "no-vital-checks"
[docs] class FlagMultiByteComments(metaclass=LongFlagArgument): _name = "mb-comments"
[docs] class FlagSynBinding(metaclass=LongFlagArgument): _name = "syn-binding"
[docs] class FlagPSL(metaclass=ShortFlagArgument): _name = "fpsl"
[docs] class FlagProfileArcs(metaclass=ShortFlagArgument): _name = "fprofile-arcs"
[docs] class FlagTestCoverage(metaclass=ShortFlagArgument): _name = "ftest-coverage"
[docs] class SwitchCompilerOption(metaclass=ValuedFlagListArgument): _pattern = "-{0},{1}" _name = "Wc"
[docs] class SwitchAssemblerOption(metaclass=ValuedFlagListArgument): _pattern = "-{0},{1}" _name = "Wa"
[docs] class SwitchLinkerOption(metaclass=ValuedFlagListArgument): _pattern = "-{0},{1}" _name = "Wl"
[docs] class SwitchIEEEFlavor(metaclass=LongValuedFlagArgument): _name = "ieee"
[docs] class SwitchVHDLVersion(metaclass=LongValuedFlagArgument): _name = "std"
[docs] class SwitchVHDLLibrary(metaclass=LongValuedFlagArgument): _name = "work"
[docs] class ArgListLibraryReferences(metaclass=ValuedFlagListArgument): _pattern = "-{0}{1}" _name = "P"
[docs] class ArgSourceFile(metaclass=PathArgument): pass
[docs] class ArgTopLevel(metaclass=StringArgument): pass
Parameters = CommandLineArgumentList( #Executable, CmdAnalyze, CmdElaborate, CmdRun, FlagVerbose, FlagDebug, FlagExplicit, FlagRelaxedRules, FlagWarnBinding, FlagNoVitalChecks, FlagMultiByteComments, FlagSynBinding, FlagPSL, FlagProfileArcs, FlagTestCoverage, SwitchCompilerOption, SwitchAssemblerOption, SwitchLinkerOption, SwitchIEEEFlavor, SwitchVHDLVersion, SwitchVHDLLibrary, ArgListLibraryReferences, ArgSourceFile, ArgTopLevel )
[docs] class SwitchIEEEAsserts(metaclass=LongValuedFlagArgument): _name = "ieee-asserts"
[docs] class SwitchStopDelta(metaclass=LongValuedFlagArgument): _name = "stop-delta"
[docs] class SwitchVCDWaveform(metaclass=LongValuedFlagArgument): _name = "vcd"
[docs] class SwitchVCDGZWaveform(metaclass=LongValuedFlagArgument): _name = "vcdgz"
[docs] class SwitchFastWaveform(metaclass=LongValuedFlagArgument): _name = "fst"
[docs] class SwitchGHDLWaveform(metaclass=LongValuedFlagArgument): _name = "wave"
[docs] class SwitchWaveformOptionFile(metaclass=LongValuedFlagArgument): _name = "read-wave-opt" # requires GHDL update
RunOptions = CommandLineArgumentList( SwitchIEEEAsserts, SwitchStopDelta, SwitchVCDWaveform, SwitchVCDGZWaveform, SwitchFastWaveform, SwitchGHDLWaveform, SwitchWaveformOptionFile )
[docs] def GetGHDLAnalyze(self): ghdl = GHDLAnalyze(self._platform, self._dryrun, self._binaryDirectoryPath, self._version, self._backend, logger=self._logger) for param in ghdl.Parameters: if (param is not ghdl.Executable): ghdl.Parameters[param] = None ghdl.Parameters[ghdl.CmdAnalyze] = True return ghdl
[docs] def GetGHDLElaborate(self): ghdl = GHDLElaborate(self._platform, self._dryrun, self._binaryDirectoryPath, self._version, self._backend, logger=self._logger) for param in ghdl.Parameters: if (param is not ghdl.Executable): ghdl.Parameters[param] = None ghdl.Parameters[ghdl.CmdElaborate] = True return ghdl
[docs] def GetGHDLRun(self): ghdl = GHDLRun(self._platform, self._dryrun, self._binaryDirectoryPath, self._version, self._backend, logger=self._logger) for param in ghdl.Parameters: if (param is not ghdl.Executable): ghdl.Parameters[param] = None ghdl.Parameters[ghdl.CmdRun] = True return ghdl
[docs]class GHDLAnalyze(GHDL): def __init__(self, platform, dryrun, binaryDirectoryPath, version, backend, logger=None): super().__init__(platform, dryrun, binaryDirectoryPath, version, backend, logger=logger)
[docs] def Analyze(self): parameterList = self.Parameters.ToArgumentList() parameterList.insert(0, self.Executable) self.LogVerbose("command: {0}".format(" ".join(parameterList))) try: self.StartProcess(parameterList) except Exception as ex: raise GHDLException("Failed to launch GHDL analyze.") from ex self._hasOutput = False self._hasWarnings = False self._hasErrors = False try: iterator = iter(GHDLAnalyzeFilter(self.GetReader())) line = next(iterator) self._hasOutput = True self.LogNormal("ghdl analyze messages for '{0}'".format(self.Parameters[self.ArgSourceFile]), indent=1) self.LogNormal(("-" * (78 - self.Logger.BaseIndent*2)), indent=1) while True: self._hasWarnings |= (line.Severity is Severity.Warning) self._hasErrors |= (line.Severity is Severity.Error) line.IndentBy(self.Logger.BaseIndent + 1) self.Log(line) line = next(iterator) except DryRunException: pass except StopIteration: pass finally: if self._hasOutput: self.LogNormal(("-" * (78 - self.Logger.BaseIndent*2)), indent=1)
[docs]class GHDLElaborate(GHDL): def __init__(self, platform, dryrun, binaryDirectoryPath, version, backend, logger=None): super().__init__(platform, dryrun, binaryDirectoryPath, version, backend, logger=logger)
[docs] def Elaborate(self): parameterList = self.Parameters.ToArgumentList() parameterList.insert(0, self.Executable) self.LogVerbose("command: {0}".format(" ".join(parameterList))) try: self.StartProcess(parameterList) except Exception as ex: raise GHDLException("Failed to launch GHDL elaborate.") from ex self._hasOutput = False self._hasWarnings = False self._hasErrors = False try: iterator = iter(GHDLElaborateFilter(self.GetReader())) line = next(iterator) line.IndentBy(self.Logger.BaseIndent + 1) self._hasOutput = True vhdlLibraryName = self.Parameters[self.SwitchVHDLLibrary] topLevel = self.Parameters[self.ArgTopLevel] self.LogNormal("ghdl elaborate messages for '{0}.{1}'".format(vhdlLibraryName, topLevel), indent=1) self.LogNormal(("-" * (78 - self.Logger.BaseIndent*2)), indent=1) self.Log(line) while True: self._hasWarnings |= (line.Severity is Severity.Warning) self._hasErrors |= (line.Severity is Severity.Error) line = next(iterator) line.IndentBy(self.Logger.BaseIndent + 1) self.Log(line) except DryRunException: pass except StopIteration: pass finally: if self._hasOutput: self.LogNormal(("-" * (78 - self.Logger.BaseIndent*2)), indent=1)
[docs]class GHDLRun(GHDL): def __init__(self, platform, dryrun, binaryDirectoryPath, version, backend, logger=None): super().__init__(platform, dryrun, binaryDirectoryPath, version, backend, logger=logger)
[docs] def Run(self): parameterList = self.Parameters.ToArgumentList() parameterList += self.RunOptions.ToArgumentList() parameterList.insert(0, self.Executable) self.LogVerbose("command: {0}".format(" ".join(parameterList))) try: self.StartProcess(parameterList) except Exception as ex: raise GHDLException("Failed to launch GHDL run.") from ex self._hasOutput = False self._hasWarnings = False self._hasErrors = False simulationResult = CallByRefParam(SimulationResult.Error) try: iterator = iter(PoCSimulationResultFilter(GHDLRunFilter(self.GetReader()), simulationResult)) line = next(iterator) line.IndentBy(self.Logger.BaseIndent + 1) self._hasOutput = True vhdlLibraryName = self.Parameters[self.SwitchVHDLLibrary] topLevel = self.Parameters[self.ArgTopLevel] self.LogNormal("ghdl run messages for '{0}.{1}'".format(vhdlLibraryName, topLevel), indent=1) self.LogNormal("-" * 78, indent=1) self.Log(line) while True: self._hasWarnings |= (line.Severity is Severity.Warning) self._hasErrors |= (line.Severity is Severity.Error) line = next(iterator) line.IndentBy(self.Logger.BaseIndent + 1) self.Log(line) except DryRunException: simulationResult <<= SimulationResult.DryRun except StopIteration: pass finally: if self._hasOutput: self.LogNormal("-" * 78, indent=1) return simulationResult.value
[docs]def GHDLAnalyzeFilter(gen): filterPattern = r".+?:\d+:\d+:(?P<warning>warning:)? (?P<message>.*)" # <Path>:<line>:<column>:[warning:] <message> filterRegExp = re_compile(filterPattern) for line in gen: filterMatch = filterRegExp.match(line) if ("ghdl: compilation error" in line): yield LogEntry(line, Severity.Error) continue elif (filterMatch is not None): if (filterMatch.group('warning') is not None): yield LogEntry(line, Severity.Warning) continue message = filterMatch.group('message') if message.endswith("has changed and must be reanalysed"): raise GHDLReanalyzeException(message) yield LogEntry(line, Severity.Error) continue yield LogEntry(line, Severity.Normal)
GHDLElaborateFilter = GHDLAnalyzeFilter
[docs]def GHDLRunFilter(gen): # Pattern Classification # ------------------------------------------------------------------------------------------------------ # <path>:<line>:<column>: <message> -> Severity.Error (by (*)) # <path>:<line>:<column>:<severity>: <message> -> According to <severity> # <path>:<line>:<column>:@<time>:(report <severity>): <message> -> According to <severity> # others -> Severity.Normal # (*) -> unknown <severity> -> Severity.Error filterPattern = r".+?:\d+:\d+:((?P<report>@\w+:\((?:report|assertion) )?(?P<severity>\w+)(?(report)\)):)? (?P<message>.*)" filterRegExp = re_compile(filterPattern) lineno = 0 for line in gen: if (lineno < 2): lineno += 1 if ("Linking in memory" in line): yield LogEntry(line, Severity.Verbose) continue if ("Starting simulation" in line): yield LogEntry(line, Severity.Verbose) continue filterMatch = filterRegExp.match(line) if filterMatch is not None: yield LogEntry(line, Severity.ParseVHDLSeverityLevel(filterMatch.group('severity'), Severity.Error)) continue yield LogEntry(line, Severity.Normal)