Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

linkers: simplify and annotate

Browse Source 
I started out just annotating, but realized there is a lot of really
silly duplication of methods in this module. Nearly all of the methods
return [], but each class implemented the same methods over and over!
I've fixed this by moving the default implementation down into the
`StaticLinker` class, and then overriding as necessary in the derived
classes.
pull/5700/head
Dylan Baker 6 years ago committed by Nirbheek Chauhan
parent 753587ee15
commit 32c57ca782
1 changed files with 81 additions and 153 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 234
      mesonbuild/linkers.py

234
mesonbuild/linkers.py
Unescape View File

@ -12,85 +12,117 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import typing
from .mesonlib import Popen_safe, is_windows from .mesonlib import Popen_safe, is_windows
from . import mesonlib from . import mesonlib
if typing.TYPE_CHECKING:
from .coredata import OptionDictType
from .environment import Environment
class StaticLinker: class StaticLinker:
def can_linker_accept_rsp(self):
def __init__(self, exelist: typing.List[str]):
self.exelist = exelist
def can_linker_accept_rsp(self) -> bool:
""" """
Determines whether the linker can accept arguments using the @rsp syntax. Determines whether the linker can accept arguments using the @rsp syntax.
""" """
return mesonlib.is_windows() return mesonlib.is_windows()
def get_exelist(self) -> typing.List[str]:
return self.exelist.copy()
class VisualStudioLikeLinker: def get_std_link_args(self) -> typing.List[str]:
always_args = ['/NOLOGO'] return []
def __init__(self, exelist, machine): def get_buildtype_linker_args(self, buildtype: str) -> typing.List[str]:
self.exelist = exelist return []
self.machine = machine
def get_exelist(self): def get_output_args(self, target: str) -> typing.List[str]:
return self.exelist.copy() return[]
def get_std_link_args(self): def get_coverage_link_args(self) -> typing.List[str]:
return [] return []
def get_buildtype_linker_args(self, buildtype): def build_rpath_args(self, build_dir: str, from_dir: str, rpath_paths: str,
build_rpath: str, install_rpath: str) -> typing.List[str]:
return [] return []
def get_output_args(self, target): def thread_link_flags(self, env: 'Environment') -> typing.List[str]:
args = [] return []
if self.machine:
args += ['/MACHINE:' + self.machine]
args += ['/OUT:' + target]
return args
def get_coverage_link_args(self): def openmp_flags(self) -> typing.List[str]:
return [] return []
def get_always_args(self): def get_option_link_args(self, options: 'OptionDictType') -> typing.List[str]:
return self.always_args.copy() return []
def get_linker_always_args(self): @classmethod
return self.always_args.copy() def unix_args_to_native(cls, args: typing.List[str]) -> typing.List[str]:
return args
def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath): def get_link_debugfile_args(self, targetfile: str) -> typing.List[str]:
# Static libraries do not have PDB files
return [] return []
def thread_link_flags(self, env): def get_always_args(self) -> typing.List[str]:
return [] return []
def openmp_flags(self): def get_linker_always_args(self) -> typing.List[str]:
return [] return []
def get_option_link_args(self, options):
return [] class VisualStudioLikeLinker:
always_args = ['/NOLOGO']
def __init__(self, machine: str):
self.machine = machine
def get_always_args(self) -> typing.List[str]:
return self.always_args.copy()
def get_linker_always_args(self) -> typing.List[str]:
return self.always_args.copy()
def get_output_args(self, target: str) -> typing.List[str]:
args = [] # type: typing.List[str]
if self.machine:
args += ['/MACHINE:' + self.machine]
args += ['/OUT:' + target]
return args
@classmethod @classmethod
def unix_args_to_native(cls, args): def unix_args_to_native(cls, args: typing.List[str]) -> typing.List[str]:
from .compilers import VisualStudioCCompiler from .compilers import VisualStudioCCompiler
return VisualStudioCCompiler.unix_args_to_native(args) return VisualStudioCCompiler.unix_args_to_native(args)
def get_link_debugfile_args(self, targetfile):
# Static libraries do not have PDB files
return []
class VisualStudioLinker(VisualStudioLikeLinker, StaticLinker): class VisualStudioLinker(VisualStudioLikeLinker, StaticLinker):
"""Microsoft's lib static linker.""" """Microsoft's lib static linker."""
def __init__(self, exelist: typing.List[str], machine: str):
StaticLinker.__init__(self, exelist)
VisualStudioLikeLinker.__init__(self, machine)
class IntelVisualStudioLinker(VisualStudioLikeLinker, StaticLinker): class IntelVisualStudioLinker(VisualStudioLikeLinker, StaticLinker):
"""Intel's xilib static linker.""" """Intel's xilib static linker."""
def __init__(self, exelist: typing.List[str], machine: str):
StaticLinker.__init__(self, exelist)
VisualStudioLikeLinker.__init__(self, machine)
class ArLinker(StaticLinker): class ArLinker(StaticLinker):
def __init__(self, exelist): def __init__(self, exelist: typing.List[str]):
self.exelist = exelist super().__init__(exelist)
self.id = 'ar' self.id = 'ar'
pc, stdo = Popen_safe(self.exelist + ['-h'])[0:2] pc, stdo = Popen_safe(self.exelist + ['-h'])[0:2]
# Enable deterministic builds if they are available. # Enable deterministic builds if they are available.
@ -99,85 +131,38 @@ class ArLinker(StaticLinker):
else: else:
self.std_args = ['csr'] self.std_args = ['csr']
def can_linker_accept_rsp(self): def get_std_link_args(self) -> typing.List[str]:
return mesonlib.is_windows()
def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
return []
def get_exelist(self):
return self.exelist[:]
def get_std_link_args(self):
return self.std_args return self.std_args
def get_output_args(self, target): def get_output_args(self, target: str) -> typing.List[str]:
return [target] return [target]
def get_buildtype_linker_args(self, buildtype):
return []
def get_linker_always_args(self):
return []
def get_coverage_link_args(self):
return []
def get_always_args(self):
return []
def thread_link_flags(self, env):
return []
def openmp_flags(self):
return []
def get_option_link_args(self, options):
return []
@classmethod
def unix_args_to_native(cls, args):
return args[:]
def get_link_debugfile_args(self, targetfile):
return []
class ArmarLinker(ArLinker): class ArmarLinker(ArLinker):
def __init__(self, exelist): def __init__(self, exelist: typing.List[str]):
self.exelist = exelist StaticLinker.__init__(self, exelist)
self.id = 'armar' self.id = 'armar'
self.std_args = ['-csr'] self.std_args = ['-csr']
def can_linker_accept_rsp(self): def can_linker_accept_rsp(self) -> bool:
# armar cann't accept arguments using the @rsp syntax # armar cann't accept arguments using the @rsp syntax
return False return False
class DLinker(StaticLinker): class DLinker(StaticLinker):
def __init__(self, exelist, arch): def __init__(self, exelist: typing.List[str], arch: str):
self.exelist = exelist super().__init__(exelist)
self.id = exelist[0] self.id = exelist[0]
self.arch = arch self.arch = arch
def can_linker_accept_rsp(self): def get_std_link_args(self) -> typing.List[str]:
return mesonlib.is_windows()
def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
return []
def get_exelist(self):
return self.exelist[:]
def get_std_link_args(self):
return ['-lib'] return ['-lib']
def get_output_args(self, target): def get_output_args(self, target: str) -> typing.List[str]:
return ['-of=' + target] return ['-of=' + target]
def get_buildtype_linker_args(self, buildtype): def get_linker_always_args(self) -> typing.List[str]:
return []
def get_linker_always_args(self):
if is_windows(): if is_windows():
if self.arch == 'x86_64': if self.arch == 'x86_64':
return ['-m64'] return ['-m64']
@ -186,75 +171,18 @@ class DLinker(StaticLinker):
return ['-m32'] return ['-m32']
return [] return []
def get_coverage_link_args(self):
return []
def get_always_args(self):
return []
def thread_link_flags(self, env):
return []
def openmp_flags(self):
return []
def get_option_link_args(self, options):
return []
@classmethod
def unix_args_to_native(cls, args):
return args[:]
def get_link_debugfile_args(self, targetfile):
return []
class CcrxLinker(StaticLinker): class CcrxLinker(StaticLinker):
def __init__(self, exelist): def __init__(self, exelist: typing.List[str]):
self.exelist = exelist super().__init__(exelist)
self.id = 'rlink' self.id = 'rlink'
pc, stdo = Popen_safe(self.exelist + ['-h'])[0:2]
self.std_args = []
def can_linker_accept_rsp(self): def can_linker_accept_rsp(self) -> bool:
return False return False
def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath): def get_output_args(self, target: str) -> typing.List[str]:
return []
def get_exelist(self):
return self.exelist[:]
def get_std_link_args(self):
return self.std_args
def get_output_args(self, target):
return ['-output=%s' % target] return ['-output=%s' % target]
def get_buildtype_linker_args(self, buildtype): def get_linker_always_args(self) -> typing.List[str]:
return []
def get_linker_always_args(self):
return ['-nologo', '-form=library'] return ['-nologo', '-form=library']
def get_coverage_link_args(self):
return []
def get_always_args(self):
return []
def thread_link_flags(self, env):
return []
def openmp_flags(self):
return []
def get_option_link_args(self, options):
return []
@classmethod
def unix_args_to_native(cls, args):
return args[:]
def get_link_debugfile_args(self, targetfile):
return []

Write Preview
Loading…
Cancel
Save