| #!/usr/bin/env python3 | |
| # Copyright lowRISC contributors. | |
| # Licensed under the Apache License, Version 2.0, see LICENSE for details. | |
| # SPDX-License-Identifier: Apache-2.0 | |
| r"""Command-line tool to validate and convert register hjson | |
| """ | |
| import argparse | |
| import logging as log | |
| import re | |
| import sys | |
| from pathlib import Path | |
| from reggen import (gen_cheader, gen_dv, gen_fpv, gen_html, | |
| gen_json, gen_rtl, gen_rust, gen_selfdoc, version) | |
| from reggen.ip_block import IpBlock | |
| from reggen.countermeasure import CounterMeasure | |
| DESC = """regtool, generate register info from Hjson source""" | |
| USAGE = ''' | |
| regtool [options] | |
| regtool [options] <input> | |
| regtool (-h | --help) | |
| regtool (-V | --version) | |
| ''' | |
| def main(): | |
| verbose = 0 | |
| parser = argparse.ArgumentParser( | |
| prog="regtool", | |
| formatter_class=argparse.RawDescriptionHelpFormatter, | |
| usage=USAGE, | |
| description=DESC) | |
| parser.add_argument('input', | |
| nargs='?', | |
| metavar='file', | |
| type=argparse.FileType('r'), | |
| default=sys.stdin, | |
| help='input file in Hjson type') | |
| parser.add_argument('-d', | |
| action='store_true', | |
| help='Output register documentation (html)') | |
| parser.add_argument('--cdefines', | |
| '-D', | |
| action='store_true', | |
| help='Output C defines header') | |
| parser.add_argument('--rust', | |
| '-R', | |
| action='store_true', | |
| help='Output Rust constants') | |
| parser.add_argument('--doc', | |
| action='store_true', | |
| help='Output source file documentation (gfm)') | |
| parser.add_argument('-j', | |
| action='store_true', | |
| help='Output as formatted JSON') | |
| parser.add_argument('-c', action='store_true', help='Output as JSON') | |
| parser.add_argument('-r', | |
| action='store_true', | |
| help='Output as SystemVerilog RTL') | |
| parser.add_argument('-s', | |
| action='store_true', | |
| help='Output as UVM Register class') | |
| parser.add_argument('-f', | |
| action='store_true', | |
| help='Output as FPV CSR rw assertion module') | |
| parser.add_argument('--outdir', | |
| '-t', | |
| help='Target directory for generated RTL; ' | |
| 'tool uses ../rtl if blank.') | |
| parser.add_argument('--dv-base-names', | |
| nargs="+", | |
| help='Names or prefix for the DV register classes from which ' | |
| 'the register models are derived.') | |
| parser.add_argument('--outfile', | |
| '-o', | |
| type=argparse.FileType('w'), | |
| default=sys.stdout, | |
| help='Target filename for json, html, gfm.') | |
| parser.add_argument('--verbose', | |
| '-v', | |
| action='store_true', | |
| help='Verbose and run validate twice') | |
| parser.add_argument('--param', | |
| '-p', | |
| type=str, | |
| default="", | |
| help='''Change the Parameter values. | |
| Only integer value is supported. | |
| You can add multiple param arguments. | |
| Format: ParamA=ValA;ParamB=ValB | |
| ''') | |
| parser.add_argument('--version', | |
| '-V', | |
| action='store_true', | |
| help='Show version') | |
| parser.add_argument('--novalidate', | |
| action='store_true', | |
| help='Skip validate, just output json') | |
| args = parser.parse_args() | |
| if args.version: | |
| version.show_and_exit(__file__, ["Hjson", "Mako"]) | |
| verbose = args.verbose | |
| if (verbose): | |
| log.basicConfig(format="%(levelname)s: %(message)s", level=log.DEBUG) | |
| else: | |
| log.basicConfig(format="%(levelname)s: %(message)s") | |
| # Entries are triples of the form (arg, (format, dirspec)). | |
| # | |
| # arg is the name of the argument that selects the format. format is the | |
| # name of the format. dirspec is None if the output is a single file; if | |
| # the output needs a directory, it is a default path relative to the source | |
| # file (used when --outdir is not given). | |
| arg_to_format = [('j', ('json', None)), ('c', ('compact', None)), | |
| ('d', ('html', None)), ('doc', ('doc', None)), | |
| ('r', ('rtl', 'rtl')), ('s', ('dv', 'dv')), | |
| ('f', ('fpv', 'fpv/vip')), ('cdefines', ('cdh', None)), | |
| ('rust', ('rs', None))] | |
| format = None | |
| dirspec = None | |
| for arg_name, spec in arg_to_format: | |
| if getattr(args, arg_name): | |
| if format is not None: | |
| log.error('Multiple output formats specified on ' | |
| 'command line ({} and {}).'.format(format, spec[0])) | |
| sys.exit(1) | |
| format, dirspec = spec | |
| if format is None: | |
| format = 'hjson' | |
| infile = args.input | |
| # Split parameters into key=value pairs. | |
| raw_params = args.param.split(';') if args.param else [] | |
| params = [] | |
| for idx, raw_param in enumerate(raw_params): | |
| tokens = raw_param.split('=') | |
| if len(tokens) != 2: | |
| raise ValueError('Entry {} in list of parameter defaults to ' | |
| 'apply is {!r}, which is not of the form ' | |
| 'param=value.' | |
| .format(idx, raw_param)) | |
| params.append((tokens[0], tokens[1])) | |
| # Define either outfile or outdir (but not both), depending on the output | |
| # format. | |
| outfile = None | |
| outdir = None | |
| if dirspec is None: | |
| if args.outdir is not None: | |
| log.error('The {} format expects an output file, ' | |
| 'not an output directory.'.format(format)) | |
| sys.exit(1) | |
| outfile = args.outfile | |
| else: | |
| if args.outfile is not sys.stdout: | |
| log.error('The {} format expects an output directory, ' | |
| 'not an output file.'.format(format)) | |
| sys.exit(1) | |
| if args.outdir is not None: | |
| outdir = args.outdir | |
| elif infile is not sys.stdin: | |
| outdir = str(Path(infile.name).parents[1].joinpath(dirspec)) | |
| else: | |
| # We're using sys.stdin, so can't infer an output directory name | |
| log.error( | |
| 'The {} format writes to an output directory, which ' | |
| 'cannot be inferred automatically if the input comes ' | |
| 'from stdin. Use --outdir to specify it manually.'.format( | |
| format)) | |
| sys.exit(1) | |
| if format == 'doc': | |
| with outfile: | |
| gen_selfdoc.document(outfile) | |
| exit(0) | |
| srcfull = infile.read() | |
| try: | |
| obj = IpBlock.from_text(srcfull, params, infile.name) | |
| except ValueError as err: | |
| log.error(str(err)) | |
| exit(1) | |
| # If this block has countermeasures, we grep for RTL annotations in all | |
| # .sv implementation files and check whether they match up with what is | |
| # defined inside the Hjson. | |
| sv_files = Path(infile.name).parents[1].joinpath('rtl').glob('*.sv') | |
| rtl_names = CounterMeasure.search_rtl_files(sv_files) | |
| obj.check_cm_annotations(rtl_names, infile.name) | |
| if args.novalidate: | |
| with outfile: | |
| gen_json.gen_json(obj, outfile, format) | |
| outfile.write('\n') | |
| else: | |
| if format == 'rtl': | |
| return gen_rtl.gen_rtl(obj, outdir) | |
| if format == 'dv': | |
| return gen_dv.gen_dv(obj, args.dv_base_names, outdir) | |
| if format == 'fpv': | |
| return gen_fpv.gen_fpv(obj, outdir) | |
| src_lic = None | |
| src_copy = '' | |
| found_spdx = None | |
| found_lunder = None | |
| copy = re.compile(r'.*(copyright.*)|(.*\(c\).*)', re.IGNORECASE) | |
| spdx = re.compile(r'.*(SPDX-License-Identifier:.+)') | |
| lunder = re.compile(r'.*(Licensed under.+)', re.IGNORECASE) | |
| for line in srcfull.splitlines(): | |
| mat = copy.match(line) | |
| if mat is not None: | |
| src_copy += mat.group(1) | |
| mat = spdx.match(line) | |
| if mat is not None: | |
| found_spdx = mat.group(1) | |
| mat = lunder.match(line) | |
| if mat is not None: | |
| found_lunder = mat.group(1) | |
| if found_lunder: | |
| src_lic = found_lunder | |
| if found_spdx: | |
| src_lic += '\n' + found_spdx | |
| with outfile: | |
| if format == 'html': | |
| return gen_html.gen_html(obj, outfile) | |
| elif format == 'cdh': | |
| return gen_cheader.gen_cdefines(obj, outfile, src_lic, src_copy) | |
| elif format == 'rs': | |
| return gen_rust.gen_rust(obj, outfile, src_lic, src_copy) | |
| else: | |
| return gen_json.gen_json(obj, outfile, format) | |
| outfile.write('\n') | |
| if __name__ == '__main__': | |
| sys.exit(main()) |