mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 04:42:53 +08:00
4a94e36819
This commit brings all the changes made by running gdb/copyright.py as per GDB's Start of New Year Procedure. For the avoidance of doubt, all changes in this commits were performed by the script.
298 lines
10 KiB
Python
Executable File
298 lines
10 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (C) 1996-2022 Free Software Foundation, Inc.
|
|
#
|
|
# This file is part of the GNU simulators.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
"""Helper to generate target-newlib-* files.
|
|
|
|
target-newlib-* are files that describe various newlib/libgloss values used
|
|
by the host/target interface. This needs to be rerun whenever the newlib source
|
|
changes. Developers manually run it.
|
|
|
|
If the path to newlib is not specified, it will be searched for in:
|
|
- the root of this source tree
|
|
- alongside this source tree
|
|
"""
|
|
|
|
import argparse
|
|
from pathlib import Path
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from typing import Iterable, List, TextIO
|
|
|
|
|
|
PROG = Path(__file__).name
|
|
|
|
# Unfortunately, many newlib/libgloss ports have seen fit to define their own
|
|
# syscall.h file. This means that system call numbers can vary for each port.
|
|
# Support for all this crud is kept here, rather than trying to get too fancy.
|
|
# If you want to try to improve this, please do, but don't break anything.
|
|
#
|
|
# If a target isn't listed here, it gets the standard syscall.h file (see
|
|
# libgloss/syscall.h) which hopefully new targets will use.
|
|
#
|
|
# NB: New ports should use libgloss, not newlib.
|
|
TARGET_DIRS = {
|
|
'cr16': 'libgloss/cr16/sys',
|
|
'd10v': 'newlib/libc/sys/d10v/sys',
|
|
# Port removed from the tree years ago.
|
|
#'i960': 'libgloss/i960',
|
|
'mcore': 'libgloss/mcore',
|
|
'riscv': 'libgloss/riscv/machine',
|
|
'sh': 'newlib/libc/sys/sh/sys',
|
|
'v850': 'libgloss/v850/sys',
|
|
}
|
|
|
|
|
|
# The header for the generated def file.
|
|
FILE_HEADER = f"""\
|
|
/* Newlib/libgloss macro values needed by remote target support. */
|
|
/* This file is machine generated by {PROG}. */\
|
|
"""
|
|
|
|
# Used to update sections of files.
|
|
START_MARKER = 'gennltvals: START'
|
|
END_MARKER = 'gennltvals: END'
|
|
|
|
|
|
def extract_syms(cpp: str, srcdir: Path,
|
|
headers: Iterable[str],
|
|
pattern: str,
|
|
filter: str = r'^$') -> dict:
|
|
"""Extract all the symbols from |headers| matching |pattern| using |cpp|."""
|
|
srcfile = ''.join(f'#include <{x}>\n' for x in headers)
|
|
syms = set()
|
|
define_pattern = re.compile(r'^#\s*define\s+(' + pattern + ')')
|
|
filter_pattern = re.compile(filter)
|
|
for header in headers:
|
|
with open(srcdir / header, 'r', encoding='utf-8') as fp:
|
|
data = fp.read()
|
|
for line in data.splitlines():
|
|
m = define_pattern.match(line)
|
|
if m and not filter_pattern.search(line):
|
|
syms.add(m.group(1))
|
|
for sym in syms:
|
|
srcfile += f'#ifdef {sym}\nDEFVAL "{sym}" {sym}\n#endif\n'
|
|
|
|
result = subprocess.run(
|
|
f'{cpp} -E -I"{srcdir}" -', shell=True, check=True, encoding='utf-8',
|
|
input=srcfile, capture_output=True)
|
|
ret = {}
|
|
for line in result.stdout.splitlines():
|
|
if line.startswith('DEFVAL '):
|
|
_, sym, val = line.split()
|
|
ret[sym.strip('"')] = val
|
|
return ret
|
|
|
|
|
|
def gentvals(output_dir: Path,
|
|
cpp: str, srctype: str, srcdir: Path,
|
|
headers: Iterable[str],
|
|
pattern: str,
|
|
filter: str = r'^$',
|
|
target: str = None):
|
|
"""Extract constants from the specified files using a regular expression.
|
|
|
|
We'll run things through the preprocessor.
|
|
"""
|
|
headers = tuple(headers)
|
|
|
|
# Require all files exist in order to regenerate properly.
|
|
for header in headers:
|
|
fullpath = srcdir / header
|
|
assert fullpath.exists(), f'{fullpath} does not exist'
|
|
|
|
syms = extract_syms(cpp, srcdir, headers, pattern, filter)
|
|
|
|
target_map = output_dir / f'target-newlib-{srctype}.c'
|
|
assert target_map.exists(), f'{target_map}: Missing skeleton'
|
|
old_lines = target_map.read_text().splitlines()
|
|
start_i = end_i = None
|
|
for i, line in enumerate(old_lines):
|
|
if START_MARKER in line:
|
|
start_i = i
|
|
if END_MARKER in line:
|
|
end_i = i
|
|
assert start_i and end_i
|
|
new_lines = old_lines[0:start_i + 1]
|
|
new_lines.extend(
|
|
f'#ifdef {sym}\n'
|
|
f' {{ "{sym}", {sym}, {val} }},\n'
|
|
f'#endif' for sym, val in sorted(syms.items()))
|
|
new_lines.extend(old_lines[end_i:])
|
|
target_map.write_text('\n'.join(new_lines) + '\n')
|
|
|
|
|
|
def gen_common(output_dir: Path, newlib: Path, cpp: str):
|
|
"""Generate the common C library constants.
|
|
|
|
No arch should override these.
|
|
"""
|
|
gentvals(output_dir, cpp, 'errno', newlib / 'newlib/libc/include',
|
|
('errno.h', 'sys/errno.h'), 'E[A-Z0-9]*')
|
|
|
|
gentvals(output_dir, cpp, 'signal', newlib / 'newlib/libc/include',
|
|
('signal.h', 'sys/signal.h'), r'SIG[A-Z0-9]*', filter=r'SIGSTKSZ')
|
|
|
|
gentvals(output_dir, cpp, 'open', newlib / 'newlib/libc/include',
|
|
('fcntl.h', 'sys/fcntl.h', 'sys/_default_fcntl.h'), r'O_[A-Z0-9]*')
|
|
|
|
|
|
def gen_target_syscall(output_dir: Path, newlib: Path, cpp: str):
|
|
"""Generate the target-specific syscall lists."""
|
|
target_map_c = output_dir / 'target-newlib-syscall.c'
|
|
old_lines_c = target_map_c.read_text().splitlines()
|
|
start_i = end_i = None
|
|
for i, line in enumerate(old_lines_c):
|
|
if START_MARKER in line:
|
|
start_i = i
|
|
if END_MARKER in line:
|
|
end_i = i
|
|
assert start_i and end_i, f'{target_map_c}: Unable to find markers'
|
|
new_lines_c = old_lines_c[0:start_i + 1]
|
|
new_lines_c_end = old_lines_c[end_i:]
|
|
|
|
target_map_h = output_dir / 'target-newlib-syscall.h'
|
|
old_lines_h = target_map_h.read_text().splitlines()
|
|
start_i = end_i = None
|
|
for i, line in enumerate(old_lines_h):
|
|
if START_MARKER in line:
|
|
start_i = i
|
|
if END_MARKER in line:
|
|
end_i = i
|
|
assert start_i and end_i, f'{target_map_h}: Unable to find markers'
|
|
new_lines_h = old_lines_h[0:start_i + 1]
|
|
new_lines_h_end = old_lines_h[end_i:]
|
|
|
|
headers = ('syscall.h',)
|
|
pattern = r'SYS_[_a-zA-Z0-9]*'
|
|
|
|
# Output the target-specific syscalls.
|
|
for target, subdir in sorted(TARGET_DIRS.items()):
|
|
syms = extract_syms(cpp, newlib / subdir, headers, pattern)
|
|
new_lines_c.append(f'CB_TARGET_DEFS_MAP cb_{target}_syscall_map[] = {{')
|
|
new_lines_c.extend(
|
|
f'#ifdef CB_{sym}\n'
|
|
' { '
|
|
f'"{sym[4:]}", CB_{sym}, TARGET_NEWLIB_{target.upper()}_{sym}'
|
|
' },\n'
|
|
'#endif' for sym in sorted(syms))
|
|
new_lines_c.append(' {NULL, -1, -1},')
|
|
new_lines_c.append('};\n')
|
|
|
|
new_lines_h.append(
|
|
f'extern CB_TARGET_DEFS_MAP cb_{target}_syscall_map[];')
|
|
new_lines_h.extend(
|
|
f'#define TARGET_NEWLIB_{target.upper()}_{sym} {val}'
|
|
for sym, val in sorted(syms.items()))
|
|
new_lines_h.append('')
|
|
|
|
# Then output the common syscall targets.
|
|
syms = extract_syms(cpp, newlib / 'libgloss', headers, pattern)
|
|
new_lines_c.append(f'CB_TARGET_DEFS_MAP cb_init_syscall_map[] = {{')
|
|
new_lines_c.extend(
|
|
f'#ifdef CB_{sym}\n'
|
|
f' {{ "{sym[4:]}", CB_{sym}, TARGET_NEWLIB_{sym} }},\n'
|
|
f'#endif' for sym in sorted(syms))
|
|
new_lines_c.append(' {NULL, -1, -1},')
|
|
new_lines_c.append('};')
|
|
|
|
new_lines_h.append('extern CB_TARGET_DEFS_MAP cb_init_syscall_map[];')
|
|
new_lines_h.extend(
|
|
f'#define TARGET_NEWLIB_{sym} {val}'
|
|
for sym, val in sorted(syms.items()))
|
|
|
|
new_lines_c.extend(new_lines_c_end)
|
|
target_map_c.write_text('\n'.join(new_lines_c) + '\n')
|
|
|
|
new_lines_h.extend(new_lines_h_end)
|
|
target_map_h.write_text('\n'.join(new_lines_h) + '\n')
|
|
|
|
|
|
def gen_targets(output_dir: Path, newlib: Path, cpp: str):
|
|
"""Generate the target-specific lists."""
|
|
gen_target_syscall(output_dir, newlib, cpp)
|
|
|
|
|
|
def gen(output_dir: Path, newlib: Path, cpp: str):
|
|
"""Generate all the things!"""
|
|
gen_common(output_dir, newlib, cpp)
|
|
gen_targets(output_dir, newlib, cpp)
|
|
|
|
|
|
def get_parser() -> argparse.ArgumentParser:
|
|
"""Get CLI parser."""
|
|
parser = argparse.ArgumentParser(
|
|
description=__doc__,
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument(
|
|
'-o', '--output', type=Path,
|
|
help='write to the specified directory')
|
|
parser.add_argument(
|
|
'--cpp', type=str, default='cpp',
|
|
help='the preprocessor to use')
|
|
parser.add_argument(
|
|
'--srcroot', type=Path,
|
|
help='the root of this source tree')
|
|
parser.add_argument(
|
|
'newlib', nargs='?', type=Path,
|
|
help='path to the newlib+libgloss source tree')
|
|
return parser
|
|
|
|
|
|
def parse_args(argv: List[str]) -> argparse.Namespace:
|
|
"""Process the command line & default options."""
|
|
parser = get_parser()
|
|
opts = parser.parse_args(argv)
|
|
|
|
if opts.output is None:
|
|
# Default to where the script lives.
|
|
opts.output = Path(__file__).resolve().parent
|
|
|
|
if opts.srcroot is None:
|
|
opts.srcroot = Path(__file__).resolve().parent.parent.parent
|
|
else:
|
|
opts.srcroot = opts.srcroot.resolve()
|
|
|
|
if opts.newlib is None:
|
|
# Try to find newlib relative to our source tree.
|
|
if (opts.srcroot / 'newlib').is_dir():
|
|
# If newlib is manually in the same source tree, use it.
|
|
if (opts.srcroot / 'libgloss').is_dir():
|
|
opts.newlib = opts.srcroot
|
|
else:
|
|
opts.newlib = opts.srcroot / 'newlib'
|
|
elif (opts.srcroot.parent / 'newlib').is_dir():
|
|
# Or see if it's alongside the gdb/binutils repo.
|
|
opts.newlib = opts.srcroot.parent / 'newlib'
|
|
if opts.newlib is None or not opts.newlib.is_dir():
|
|
parser.error('unable to find newlib')
|
|
|
|
return opts
|
|
|
|
|
|
def main(argv: List[str]) -> int:
|
|
"""The main entry point for scripts."""
|
|
opts = parse_args(argv)
|
|
|
|
gen(opts.output, opts.newlib, opts.cpp)
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main(sys.argv[1:]))
|