def main():
import argparse
parser = argparse.ArgumentParser(
description=
'Outputs a Vivavo highlight_objects command from a FASM file.')
util.db_root_arg(parser)
util.part_arg(parser)
parser.add_argument('fn_in', help='Input FPGA assembly (.fasm) file')
args = parser.parse_args()
database = db.Database(args.db_root, args.part)
grid = database.grid()
def inner():
for line in fasm.parse_fasm_filename(args.fn_in):
if not line.set_feature:
continue
parts = line.set_feature.feature.split('.')
tile = parts[0]
gridinfo = grid.gridinfo_at_tilename(tile)
tile_type = database.get_tile_type(gridinfo.tile_type)
for pip in tile_type.pips:
if pip.net_from == parts[2] and pip.net_to == parts[1]:
yield '{}/{}'.format(tile, pip.name)
print(
'highlight_objects [concat {}]'.format(
' '.join('[get_pips {}]'.format(pip) for pip in inner())))
def run(db_root, filename_in, f_out, sparse=False, debug=False):
assembler = fasm_assembler.FasmAssembler(db.Database(db_root))
assembler.parse_fasm_filename(filename_in)
frames = assembler.get_frames(sparse=sparse)
if debug:
dump_frames_sparse(frames)
dump_frm(f_out, frames)
def bits_to_fasm(db_root, bits_file, verbose, canonical):
disassembler = fasm_disassembler.FasmDisassembler(db.Database(db_root))
with open(bits_file) as f:
bitdata = bitstream.load_bitdata(f)
print(
fasm.fasm_tuple_to_string(disassembler.find_features_in_bitstream(
bitdata, verbose=verbose),
canonical=canonical))
def run(db_root, verbose=False):
# Start by running a basic check on db files
print("Checking individual .db...")
parsedb_all(db_root, verbose=verbose)
# Now load and verify tile consistency
db = prjxraydb.Database(db_root)
db._read_tilegrid()
'''
these don't load properly without .json files
See: https://github.com/SymbiFlow/prjxray/issues/303
db._read_tile_types()
print(db.tile_types.keys())
'''
verbose and print("")
print("Checking aggregate dir...")
check_tile_overlap(db, verbose=verbose)
def run(
db_root,
part,
bits_file,
segnames,
omit_empty_segs=False,
flag_unknown_bits=False,
flag_decode_emit=False,
flag_decode_omit=False,
bit_only=False,
verbose=False):
db = prjxraydb.Database(db_root, part)
tiles = load_tiles(db_root, part)
segments = mk_segments(tiles)
bitdata = bitstream.load_bitdata2(open(bits_file, "r"))
if flag_unknown_bits:
print_unknown_bits(tiles, bitdata)
print("")
# Default: print all
if segnames:
for i, segname in enumerate(segnames):
# Default to common tile config area if tile given without explicit block
if ':' not in segname:
segnames[i] = mksegment(segname, 'CLB_IO_CLK')
else:
segnames = sorted(tile_segnames(tiles))
print('Segments: %u' % len(segnames))
# XXX: previously this was sorted by address, not name
# revisit?
for segname in segnames:
handle_segment(
db,
segname,
bitdata,
flag_decode_emit,
flag_decode_omit,
omit_empty_segs,
segments,
bit_only=bit_only,
verbose=verbose)
def process_fasm(db_root, part, fasm_file, canonical):
database = db.Database(db_root, part)
grid = database.grid()
for fasm_line in fasm.parse_fasm_filename(fasm_file):
if not fasm_line.set_feature:
if not canonical:
yield fasm_line
for feature in fasm.canonical_features(fasm_line.set_feature):
parts = feature.feature.split('.')
tile = parts[0]
gridinfo = grid.gridinfo_at_tilename(tile)
tile_segbits = database.get_tile_segbits(gridinfo.tile_type)
address = 0
if feature.start is not None:
address = feature.start
feature_name = '{}.{}'.format(gridinfo.tile_type,
'.'.join(parts[1:]))
# Convert feature to bits. If no bits are set, feature is
# psuedo pip, and should not be output from canonical FASM.
bits = tuple(
tile_segbits.feature_to_bits(feature_name, address=address))
if len(bits) == 0 and canonical:
continue
# In canonical output, only output the canonical features.
if canonical:
yield fasm.FasmLine(
set_feature=feature,
annotations=None,
comment=None,
)
# If not in canonical mode, output original FASM line
if not canonical:
yield fasm_line
def main():
import argparse
parser = argparse.ArgumentParser(
description=
'Outputs a Vivavo highlight_objects command from a FASM file.')
database_dir = os.getenv("XRAY_DATABASE_DIR")
database = os.getenv("XRAY_DATABASE")
db_root_kwargs = {}
if database_dir is None or database is None:
db_root_kwargs['required'] = True
else:
db_root_kwargs['required'] = False
db_root_kwargs['default'] = os.path.join(database_dir, database)
parser.add_argument('--db-root', help="Database root.", **db_root_kwargs)
parser.add_argument('fn_in', help='Input FPGA assembly (.fasm) file')
args = parser.parse_args()
database = db.Database(args.db_root)
grid = database.grid()
def inner():
for line in fasm.parse_fasm_filename(args.fn_in):
if not line.set_feature:
continue
parts = line.set_feature.feature.split('.')
tile = parts[0]
gridinfo = grid.gridinfo_at_tilename(tile)
tile_type = database.get_tile_type(gridinfo.tile_type)
for pip in tile_type.pips:
if pip.net_from == parts[2] and pip.net_to == parts[1]:
yield '{}/{}'.format(tile, pip.name)
print('highlight_objects [concat {}]'.format(' '.join(
'[get_pips {}]'.format(pip) for pip in inner())))
