# SPDX-License-Identifier: Apache-2.0
#
# This file is part of the M2-ISA-R project: https://github.com/tum-ei-eda/M2-ISA-R
#
# Copyright (C) 2022
# Chair of Electrical Design Automation
# Technical University of Munich
import itertools
import logging
from typing import Union
from ... import (M2DuplicateError, M2NameError, M2TypeError, M2ValueError,
flatten)
from ...metamodel import arch, behav, type_info, attribute_info, intrinsics
from ...metamodel.code_info import FunctionInfoFactory
from ..coredsl2.parser_gen import CoreDSL2Parser, CoreDSL2Visitor
from ..coredsl2.utils import RADIX, SHORTHANDS, SIGNEDNESS
from ..coredsl2.expr_interpreter import ExprInterpreterVisitor
from ..coredsl2.source_location import line_info
[docs]
logger = logging.getLogger("arch_builder")
[docs]
exprInterpretVisitor = ExprInterpreterVisitor()
[docs]
class ArchitectureModelBuilder(CoreDSL2Visitor):
"""ANTLR visitor to build an M2-ISA-R architecture model of a CoreDSL 2 specification."""
[docs]
_parameters: "dict[str, arch.Parameter]"
[docs]
_instructions: "list[arch.Instruction]"
[docs]
_functions: "dict[str, arch.Function]"
[docs]
_always_blocks: "dict[str, arch.AlwaysBlock]"
[docs]
_instruction_sets: "dict[str, arch.InstructionSet]"
[docs]
_read_types: "dict[str, str]"
[docs]
_memories: "dict[str, arch.Memory]"
[docs]
_memory_aliases: "dict[str, arch.Alias]"
[docs]
_register_banks: "dict[str, Union[arch.RegisterBank, arch.Register]]"
[docs]
_register_aliases: "dict[str, arch.Alias]"
[docs]
_overwritten_instrs: "list[tuple[arch.Instruction, arch.Instruction]]"
[docs]
_instr_classes: "set[int]"
[docs]
_main_reg_file: Union[arch.RegisterBank, None]
[docs]
_float_reg_file: Union[arch.RegisterBank, None]
[docs]
_vector_reg_file: Union[arch.RegisterBank, None]
[docs]
_csr_reg_file: Union[arch.RegisterBank, None]
def __init__(self, merge: bool = False, attributes_validated: bool = False, parameter_values=None):
super().__init__()
self._parameters = {}
# self._instructions = {}
self._instructions = []
self._functions = {}
self._always_blocks = {}
self._instruction_sets = {}
self._read_types = {}
self._memories = {}
self._memory_aliases = {}
self._register_banks = {}
self._register_aliases = {}
self._overwritten_instrs = []
self._instr_classes = set()
self._main_reg_file = None
self._float_reg_file = None
self._vector_reg_file = None
self._csr_reg_file = None
[docs]
self.attributes_validated = attributes_validated
[docs]
self.parameter_values = parameter_values or {}
[docs]
def visitBit_field(self, ctx: CoreDSL2Parser.Bit_fieldContext):
"""Generate a bit field (instruction parameter in encoding)."""
# generate lower and upper bounds
left = self.visit(ctx.left)
right = self.visit(ctx.right)
# instantiate M2-ISA-R objects
range_spec = arch.RangeSpec(left.value, right.value)
return arch.BitField(ctx.name.text, range_spec, type_info.TypeKind.UINT)
[docs]
def visitBit_value(self, ctx: CoreDSL2Parser.Bit_valueContext):
"""Generate a fixed encoding part."""
val = self.visit(ctx.value)
return arch.BitVal(val.ty.size, val.value)
[docs]
def visitAuto_field(self, ctx: CoreDSL2Parser.Auto_fieldContext):
"""Generate undefined part of encoding."""
# import traceback
# traceback.print_stack()
# input("1")
return None
[docs]
def visitInstruction_set(self, ctx: CoreDSL2Parser.Instruction_setContext):
"""Generate a top-level instruction set object."""
# keep track of seen instruction set names
self._read_types[ctx.name.text] = None
name = ctx.name.text
extension = []
if ctx.extension:
if len(ctx.extension) > 1:
logger.warning("Extending more than one InstrSet is not CoreDSL2 compiliant!")
extension = [obj.text for obj in ctx.extension]
combines = []
if ctx.combines:
combines = [obj.text for obj in ctx.combines]
assert len(ctx.sections) == 0
sections = []
else:
sections = ctx.sections
# generate flat list of instruction set contents
contents = flatten([self.visit(obj) for obj in sections])
parameters = {}
memories = {}
memory_aliases = {}
register_banks = {}
register_aliases = {}
functions = {}
always_blocks = {}
# instructions = {}
instructions = []
# instructions += self._instructions
if self.merge:
parameters.update(self._parameters)
memories.update(self._memories)
memory_aliases.update(self._memory_aliases)
register_banks.update(self._register_banks)
register_aliases.update(self._register_aliases)
functions.update(self._functions)
# group contents by type
for item in contents:
if item is None:
continue
if isinstance(item, arch.Parameter):
parameters[item.name] = item
elif isinstance(item, arch.Memory):
memories[item.name] = item
elif isinstance(item, (arch.RegisterBank, arch.Register)):
register_banks[item.name] = item
elif isinstance(item, arch.Alias):
assert item.parent is not None
if isinstance(item.parent, arch.Memory):
memory_aliases[item.name] = item
elif isinstance(item.parent, (arch.RegisterBank, arch.Register)):
register_aliases[item.name] = item
else:
raise M2TypeError(f"Unhandled alias parent type: {type(item.parent)}")
register_aliases[item.name] = item
elif isinstance(item, arch.Function):
functions[item.name] = item
item.ext_name = name
elif isinstance(item, arch.Instruction):
# instructions[(item.code, item.mask)] = item
instructions.append(item)
item.ext_name = name
elif isinstance(item, arch.AlwaysBlock):
always_blocks[item.name] = item
else:
raise M2ValueError(f"unexpected item encountered: {type(item)}")
# instantiate M2-ISA-R object
if ctx.combines:
i = arch.InstructionSetGroup(name, combines)
else:
i = arch.InstructionSet(name, extension, parameters, memories, memory_aliases, register_banks, register_aliases, functions, instructions, {}, always_blocks)
if name in self._instruction_sets:
raise M2DuplicateError(f"instruction set \"{name}\" already defined")
# keep track of instruction set object
self._instruction_sets[name] = i
return i
[docs]
def visitSection_instructions(self, ctx: CoreDSL2Parser.Section_instructionsContext):
attributes = dict([self.visit(obj) for obj in ctx.attributes])
instructions: "list[arch.Instruction]" = [self.visit(obj) for obj in ctx.instructions]
for attr, val in attributes.items():
for instr in instructions:
if attr not in instr.attributes:
instr.attributes[attr] = val
return instructions
[docs]
def visitCore_def(self, ctx: CoreDSL2Parser.Core_defContext):
"""Generate a top-level CoreDef object."""
self.visitChildren(ctx)
name = ctx.name.text
c = arch.CoreDef(name, list(self._read_types.keys()), None,
self._parameters, self._memories, self._memory_aliases,
self._register_banks, self._register_aliases, self._functions,
self._instructions, {}, self._instr_classes, intrinsics, self._always_blocks)
return c
[docs]
def visitSection_arch_state(self, ctx: CoreDSL2Parser.Section_arch_stateContext):
"""Generate "archictectural_state" section of CoreDSL file."""
# Resolve enums before declarations that use their members as widths.
from types import SimpleNamespace
from .source_semantics import SemanticValidator, DslSymbol
validator = SemanticValidator(SimpleNamespace(definitions=[ctx.parentCtx]), None)
validator.build_symbols([ctx.parentCtx])
for name, parameter in self._parameters.items():
if name not in validator.symbols:
validator.symbols[name] = DslSymbol(storage='param', known_value=parameter.value, model=parameter)
enum_constants = []
for enum in ctx.enum_types:
ty = validator.enum_type(enum)
if ty.kind != 'enum':
raise M2TypeError(f"Cannot lower unresolved enum {enum.name.text}")
for name, value in ty.members.items():
parameter = arch.Parameter(name, value, {}, ty.width, ty.element.signed)
parameter._coredsl_enum_name = enum.name.text
self._parameters[parameter.name] = parameter
enum_constants.append(parameter)
decls = enum_constants + list(itertools.chain.from_iterable(self.visit(obj) for obj in ctx.declarations))
for obj in ctx.expressions:
self.visit(obj)
return decls
[docs]
def visitAlways_block(self, ctx: CoreDSL2Parser.Always_blockContext):
"""Generate always block"""
name = ctx.name.text
attributes = dict([self.visit(obj) for obj in ctx.attributes])
a = arch.AlwaysBlock(name, attributes, ctx.behavior)
self._always_blocks[name] = a
return a
[docs]
def visitInstruction(self, ctx: CoreDSL2Parser.InstructionContext):
"""Generate non-behavioral parts of an instruction."""
# print("visitInstruction")
# read encoding, attributes and disassembly
encoding = [self.visit(obj) for obj in ctx.encoding]
operands = {}
for obj in ctx.operands:
operand = self.visit(obj)
if operand.name in operands:
raise M2DuplicateError(f"operand {operand.name} already defined for instruction {ctx.name.text}")
operands[operand.name] = operand
attributes = dict([self.visit(obj) for obj in ctx.attributes])
assembly = ctx.assembly.text.replace("\"", "") if ctx.assembly is not None else None
mnemonic = ctx.mnemonic.text.replace("\"", "") if ctx.mnemonic is not None else None
if assembly is None:
assembly = ", ".join("{" + operand_name + "}" for operand_name in operands)
name = ctx.name.text
# Encoding syntax has no signedness marker; explicit operand types
# supply the type of each corresponding field.
for field in encoding:
if isinstance(field, arch.BitField) and field.name in operands:
field.ty.kind = type_info.TypeKind.INT if operands[field.name].signed else type_info.TypeKind.UINT
i = arch.Instruction(
name=name,
attributes=attributes,
operands=operands,
encoding=encoding,
mnemonic=mnemonic,
assembly=assembly,
operation=ctx.behavior,
function_info=None,
)
# Preserve source metadata for ETISS instrumentation and coverage reports.
opcode_str = "{code:0{width}x}:{mask:0{width}x}".format(code=i.code, mask=i.mask, width=(i.size or 0)//4) if i.has_encoding else "auto"
i.function_info = FunctionInfoFactory.make(
ctx.start.source[1].fileName, ctx.start.start, ctx.stop.stop,
ctx.start.line, ctx.stop.line, f"instr_{i.name}_{opcode_str}")
if i.has_encoding:
self._instr_classes.add(i.size)
instr_id = (i.code, i.mask)
# instr_id = (i.code, i.mask)
# check for duplicate instructions
if instr_id in self._instructions:
self._overwritten_instrs.append((self._instructions[instr_id], i))
# check for duplicate instructions
# if instr_id in self._instructions:
# self._overwritten_instrs.append((self._instructions[instr_id], i))
# keep track of instruction
# self._instructions[instr_id] = i
self._instructions.append(i)
return i
[docs]
def visitOperand_declaration(self, ctx: CoreDSL2Parser.Operand_declarationContext):
"""Generate an explicitly declared instruction operand."""
type_ = self.visit(ctx.type_)
decl = ctx.decl
if not isinstance(type_, type_info.PrimitiveType) or not type_.kind.is_int:
raise M2TypeError(f"operand {decl.name.text} must have an integer type")
if decl.size or decl.init is not None:
raise M2TypeError(f"operand {decl.name.text} cannot be an array or have an initializer")
attributes = dict([self.visit(obj) for obj in decl.attributes])
return arch.Parameter(
decl.name.text,
None,
attributes,
type_.size,
type_.kind == type_info.TypeKind.INT,
)
[docs]
def visitFunction_definition(self, ctx: CoreDSL2Parser.Function_definitionContext):
"""Generate non-behavioral parts of a function."""
# decode attributes
attributes = dict([self.visit(obj) for obj in ctx.attributes])
if attribute_info.FunctionAttribute.ETISS_TRAP_ENTRY_FN in attributes:
attributes[attribute_info.FunctionAttribute.ETISS_NEEDS_ARCH] = []
# decode return type and name
type_ = self.visit(ctx.type_)
name = ctx.name.text
# decode function arguments
params = []
if ctx.params:
params = self.visit(ctx.params)
if not isinstance(params, list):
params = [params]
return_size = None
data_type = type_info.TypeKind.VOID
if isinstance(type_, type_info.PrimitiveType):
return_size = type_.size
data_type = type_.kind
f = arch.Function(name, attributes, return_size, data_type, params, ctx.behavior, ctx.extern is not None)
if not f.extern:
from .source_validator import return_terminated
f._coredsl_return_terminated = return_terminated(ctx.behavior)
f.function_info = FunctionInfoFactory.make(ctx.start.source[1].fileName, ctx.start.start, ctx.stop.stop, ctx.start.line, ctx.stop.line, "fn_" + f.name)
# error on duplicate function definition
# TODO: implement overwriting function prototypes?
f2 = self._functions.get(name, None)
if f2 is not None:
if len(f2.operation.statements) > 0:
raise M2DuplicateError(f"function \"{name}\" already defined")
self._functions.pop(name)
self._functions[name] = f
return f
[docs]
def visitParameter_declaration(self, ctx: CoreDSL2Parser.Parameter_declarationContext):
"""Generate function argument declaration."""
# type is required, name and array size optional
type_ = self.visit(ctx.type_)
name = None
size = None
if ctx.decl:
if ctx.decl.name:
name = ctx.decl.name.text
if ctx.decl.size:
size = [self.visit(obj) for obj in ctx.decl.size]
p = arch.FnParam(name, type_)
return p
[docs]
def visitInteger_constant(self, ctx: CoreDSL2Parser.Integer_constantContext):
"""Generate an integer literal."""
from .constant_expressions import integer_literal
from ...diagnostics import M2ValidationError
source_info = line_info(ctx)
try:
value, width, signed = integer_literal(ctx.value.text)
except ValueError as exc:
raise M2ValidationError(str(exc), 'org.eclipse.xtext.diagnostics.Diagnostic.Syntax', source_info) from exc
kind = type_info.TypeKind.INT if signed else type_info.TypeKind.UINT
return behav.Literal(value, type_info.PrimitiveType(kind, width), line_info=source_info)
[docs]
def visitDeclaration(self, ctx: CoreDSL2Parser.DeclarationContext):
"""Generate a declaration."""
# extract storage type, qualifiers and attributes
storage = [self.visit(obj) for obj in ctx.storage]
qualifiers = [self.visit(obj) for obj in ctx.qualifiers]
attributes = dict([self.visit(obj) for obj in ctx.attributes])
# extract data type
type_ = self.visit(ctx.type_)
assert isinstance(type_, (type_info.PrimitiveType, type_info.PointerType))
# extract list of contained declarations for the given type
decls: "list[CoreDSL2Parser.DeclaratorContext]" = ctx.declarations
ret_decls = []
# generate each declaration
for decl in decls:
name = decl.name.text
# generate a register alias
if isinstance(type_, type_info.PointerType):
# error out on duplicate declaration
if name in self._memory_aliases or name in self._register_aliases:
raise M2DuplicateError(f"memory {name} already defined")
# assume default size
size = [1]
# alias needs to have a reference as initializer
init: behav.IndexedReference = self.visit(decl.init)
attributes = {}
# extract array size
if decl.size:
size = [self.visit(obj).value for obj in decl.size]
# extract referenced object and indices
left = init.index
right = init.right if init.right is not None else left
reference = init.reference
if decl.attributes:
attributes = dict([self.visit(obj) for obj in decl.attributes])
range_spec = arch.RangeSpec(left, right)
#if range.length != size[0]:
# raise ValueError(f"range mismatch for \"{name}\"")
# instantiate M2-ISA-R object, keep track of parent - child relations
if attribute_info.RegisterAttribute.IS_PC in attributes:
raise NotImplementedError(f"The program counter must be a register not an alias with name {name}")
# Alias require a range to store details in Array, where it exactly points to (Ty is lhs info)
alias = arch.Alias(name, reference, range_spec, type_, attributes)
alias.coredsl_const = 'const' in qualifiers
alias.parent.children.append(alias)
# keep track of this declaration globally
if isinstance(reference, (arch.RegisterBank, arch.Register)):
self._register_aliases[name] = alias
elif isinstance(reference, arch.Memory):
self._memory_aliases[name] = alias
else:
raise M2TypeError("invalid alias reference type")
# keep track of this declaration for this declaration statement
ret_decls.append(alias)
# normal declaration
else:
# no storage specifier -> implementation parameter, "Constant" in M2-ISA-R
if len(storage) == 0:
if name in self._parameters:
raise M2DuplicateError(f"Parameter {name} already defined")
# extract initializer if present
init = None
if decl.init is not None:
init = self.visit(decl.init)
signed = True if type_.kind == type_info.TypeKind.INT else False
c = arch.Parameter(name, init, [], type_.size, signed)
if init is not None:
c._initializer_expressions = [(type_, init)]
if name in self.parameter_values:
c.value = self.parameter_values[name]
self._parameters[name] = c
ret_decls.append(c)
# register and extern declaration: "Memory" object in M2-ISA-R
elif "register" in storage:
if name in self._register_banks:
raise M2DuplicateError(f"register bank {name} already defined")
size = [1]
init = None
attributes = {}
if decl.size:
size = [self.visit(obj) for obj in decl.size]
if len(size) > 1:
raise NotImplementedError("arrays with more than one dimension are not supported")
if decl.init is not None:
init = self.visit(decl.init)
if decl.attributes:
attributes = dict([self.visit(obj) for obj in decl.attributes])
reg = None
# TODO: Constant might be 1 as well and makes a RegisterBank to Register ... [1] should be illegal anyways?
if isinstance(size[0], (arch.Parameter, behav.NamedReference)):
reg = arch.RegisterBank(name, size[0], type_.kind, type_.size, attributes)
reg.coredsl_const = 'const' in qualifiers
elif isinstance(size[0], behav.Literal):
if size[0].value >= 1:
reg = arch.RegisterBank(name, size[0].value, type_.kind, type_.size, attributes)
reg.coredsl_const = 'const' in qualifiers
elif size[0].value == 1:
reg = arch.Register(name, type_.kind, type_.size, attributes)
reg.coredsl_const = 'const' in qualifiers
else:
M2ValueError("Size is negative for Registerbank")
elif isinstance(size[0], int):
# Unset Case: =1
reg = arch.Register(name, type_.kind, type_.size, attributes)
reg.coredsl_const = 'const' in qualifiers
else:
raise NotImplementedError("Only constant Parameter and Int allowed as dimension for register size")
assert isinstance(reg, Union[arch.Register, arch.RegisterBank])
# attach init value to register bank object
if init is not None:
if isinstance(init, list):
if not isinstance(reg.ty, type_info.ArrayType):
raise M2TypeError("List initializer requires an array")
reg._initval.update({i: exprInterpretVisitor.generate(value, None) for i, value in enumerate(init)})
reg._initializer_expressions = [(reg.ty, behav.Tensor(list(reg._initval.values()), reg.ty,
initializer_elements=init, line_info=line_info(decl)))]
else:
reg._initval[None] = exprInterpretVisitor.generate(init, None)
reg._initializer_expressions = [(reg.ty, init)]
if isinstance(reg, arch.RegisterBank):
if reg.is_main_reg:
self._main_reg_file = reg
elif reg.is_float_reg:
self._float_reg_file = reg
elif reg.is_vector_reg:
self._vector_reg_file = reg
assert sum([reg.is_main_reg, reg.is_float_reg, reg.is_vector_reg]) <= 1
self._register_banks[name] = reg
ret_decls.append(reg)
elif "extern" in storage:
if name in self._memories:
raise M2DuplicateError(f"memory {name} already defined")
size = [1]
init = None
attributes = {}
if decl.size:
size = [self.visit(obj) for obj in decl.size]
if len(size) > 1:
raise NotImplementedError("arrays with more than one dimension are not supported")
if decl.init is not None:
init = self.visit(decl.init)
if decl.attributes:
attributes = dict([self.visit(obj) for obj in decl.attributes])
m = arch.Memory(name, type_.kind, type_.size, size[0], attributes)
m.coredsl_const = 'const' in qualifiers
# attach init value to memory object
if init is not None:
if isinstance(init, list):
if not isinstance(m.ty, type_info.ArrayType):
raise M2TypeError("List initializer requires an array")
m._initval.update({i: exprInterpretVisitor.generate(value, None) for i, value in enumerate(init)})
m._initializer_expressions = [(m.ty, behav.Tensor(list(m._initval.values()), m.ty,
initializer_elements=init, line_info=line_info(decl)))]
else:
m._initval[None] = exprInterpretVisitor.generate(init, None)
m._initializer_expressions = [(m.ty if decl.size else type_, init)]
if m.is_csr_reg:
self._csr_reg_file = m
elif m.is_main_mem:
self.main_memory = m
elif m.is_vector_reg:
self._vector_reg_file = m
self._memories[name] = m
ret_decls.append(m)
return ret_decls
[docs]
def visitType_specifier(self, ctx: CoreDSL2Parser.Type_specifierContext):
type_ = self.visit(ctx.type_)
if ctx.ptr:
type_ = type_info.PointerType(type_)
# type_.ptr = ctx.ptr.text
return type_
[docs]
def visitInteger_type(self, ctx: CoreDSL2Parser.Integer_typeContext):
"""Generate an integer type specification."""
# default signedness
signed = True
# minimal integer type is just a signedness without width
width = None
# extract sign
if ctx.signed is not None:
signed = self.visit(ctx.signed)
# extract size
if ctx.size is not None:
width = self.visit(ctx.size)
# extract and decode shorthand (int = signed<32>)
if ctx.shorthand is not None:
width = self.visit(ctx.shorthand)
# type check width
if isinstance(width, behav.Literal):
width = width.value
elif isinstance(width, behav.NamedReference):
width = width.reference
else:
raise M2TypeError("width has wrong type")
kind = type_info.TypeKind.INT if signed else type_info.TypeKind.UINT
return type_info.PrimitiveType(kind, width)
[docs]
def visitEnum_reference(self, ctx):
for parameter in self._parameters.values():
if getattr(parameter, '_coredsl_enum_name', None) == ctx.name.text:
kind = type_info.TypeKind.INT if parameter.signed else type_info.TypeKind.UINT
return type_info.PrimitiveType(kind, parameter.size)
raise M2TypeError(f"Cannot lower unresolved enum type {ctx.name.text}")
[docs]
def visitVoid_type(self, ctx: CoreDSL2Parser.Void_typeContext):
"""Generate a void type."""
return type_info.PrimitiveType(type_info.TypeKind.VOID, None)
[docs]
def visitBool_type(self, ctx: CoreDSL2Parser.Bool_typeContext):
"""Generate a bool (alias for unsigned<1>)."""
return type_info.PrimitiveType(type_info.TypeKind.UINT, 1)
[docs]
def visitBinary_expression(self, ctx: CoreDSL2Parser.Binary_expressionContext):
"""Generate a binary expression."""
source_info = line_info(ctx)
# visit LHS and RHS
left = self.visit(ctx.left)
right = self.visit(ctx.right)
op = behav.Operator(ctx.bop.text, line_info=line_info(ctx))
# return M2-ISA-R object
return behav.BinaryOperation(left, op, right, line_info=source_info)
[docs]
def visitSlice_expression(self, ctx: CoreDSL2Parser.Slice_expressionContext):
left = self.visit(ctx.left)
right = self.visit(ctx.right) if ctx.right is not None else None
expr = self.visit(ctx.expr).reference
op = behav.IndexedReference(expr, left, right, line_info=line_info(ctx))
return op
[docs]
def visitPrefix_expression(self, ctx: CoreDSL2Parser.Prefix_expressionContext):
prefix = behav.Operator(ctx.prefix.text, line_info=line_info(ctx))
expr = self.visit(ctx.right)
return behav.UnaryOperation(prefix, expr, line_info=line_info(ctx))
[docs]
def visitCast_expression(self, ctx: CoreDSL2Parser.Cast_expressionContext):
from .behavior_model_builder import BehaviorModelBuilder
return BehaviorModelBuilder.visitCast_expression(self, ctx)
[docs]
def visitInitializerList(self, ctx: CoreDSL2Parser.InitializerListContext):
values = [self.visit(init) for init in ctx.initializer()]
if any(isinstance(value, list) for value in values):
raise M2TypeError("Nested list initializers are unsupported")
return values
[docs]
def visitDeref_expression(self, ctx):
raise M2TypeError("Composite member access is not supported by model lowering")
[docs]
def visitIntrinsic_expression(self, ctx):
from .behavior_model_builder import BehaviorModelBuilder
builder = BehaviorModelBuilder(self._parameters, self._memories, self._memory_aliases,
self._register_banks, self._register_aliases, {}, self._functions, set())
return builder.visitIntrinsic_expression(ctx)
[docs]
def visitReference_expression(self, ctx: CoreDSL2Parser.Reference_expressionContext):
"""Generate a referencing expression."""
name = ctx.ref.text
# try to resolve the reference, error out if invalid
ref = self._parameters.get(name) or self._memories.get(name) or self._memory_aliases.get(name) \
or self._register_banks.get(name) or self._register_aliases.get(name)
if ref is None:
raise M2NameError(f"reference \"{name}\" could not be resolved")
return behav.NamedReference(ref, line_info=line_info(ctx))
[docs]
def visitStorage_class_specifier(self, ctx: CoreDSL2Parser.Storage_class_specifierContext):
return ctx.children[0].symbol.text
[docs]
def visitType_qualifier(self, ctx: CoreDSL2Parser.Type_qualifierContext):
return ctx.children[0].symbol.text
[docs]
def visitInteger_signedness(self, ctx: CoreDSL2Parser.Integer_signednessContext):
return SIGNEDNESS[ctx.children[0].symbol.text]
[docs]
def visitInteger_shorthand(self, ctx: CoreDSL2Parser.Integer_shorthandContext):
value = SHORTHANDS[ctx.children[0].symbol.text]
return behav.Literal(value, line_info=line_info(ctx))
[docs]
def visitAssignment_expression(self, ctx: CoreDSL2Parser.Assignment_expressionContext):
"""Generate an assignment. """
# extract LHS and RHS
left = self.visit(ctx.left)
right = self.visit(ctx.right)
# if LHS is a reference, assign RHS as its default value
if isinstance(left, behav.NamedReference):
if isinstance(left.reference, arch.Parameter):
if left.reference.name not in self.parameter_values:
left.reference.value = exprInterpretVisitor.generate(right, None)
elif isinstance(left.reference, (arch.Register, arch.Alias)):
left.reference._initval[None] = exprInterpretVisitor.generate(right, None)
elif isinstance(left, behav.IndexedReference):
left.reference._initval[exprInterpretVisitor.generate(left.index, None)] = exprInterpretVisitor.generate(right, None)
else:
return
ref = left.reference
if isinstance(ref, arch.Parameter):
kind = type_info.TypeKind.INT if ref.signed else type_info.TypeKind.UINT
target_type = type_info.PrimitiveType(kind, ref.size)
elif isinstance(left, behav.IndexedReference):
target_type = ref.ty.ty if isinstance(ref.ty, type_info.PointerType) else ref.ty
count = (abs(exprInterpretVisitor.generate(left.index, None) -
exprInterpretVisitor.generate(left.right, None)) + 1
if left.right is not None else 1)
if isinstance(target_type, type_info.ArrayType):
target_type = (target_type.element_type if left.right is None else
type_info.PrimitiveType(type_info.TypeKind.UINT,
count * arch.get_const_or_val(target_type.element_type.size)))
else:
target_type = type_info.PrimitiveType(type_info.TypeKind.UINT, count)
elif isinstance(ref, arch.Alias):
target_type = ref.ty.ty
else:
target_type = ref.ty
ref._initializer_expressions = getattr(ref, '_initializer_expressions', []) + [(target_type, right)]
[docs]
def visitAttribute(self, ctx: CoreDSL2Parser.AttributeContext):
"""Generate an attribute."""
name = ctx.name.text
# read attribute from enums
attr = attribute_info.InstrAttribute._member_map_.get(name.upper()) or \
attribute_info.MemoryAttribute._member_map_.get(name.upper()) or \
attribute_info.FunctionAttribute._member_map_.get(name.upper()) \
or attribute_info.RegisterAttribute._member_map_.get(name.upper()) \
or attribute_info.AlwaysBlockAttribute._member_map_.get(name.upper()) \
or attribute_info.OperandAttribute._member_map_.get(name.upper())
# warn if attribute is unknown to M2-ISA-R
if attr is None:
if not self.attributes_validated:
logger.warning("unknown attribute \"%s\" encountered", name)
attr = name
return attr, ctx.params
[docs]
def visitChildren(self, node):
"""Helper method to return flatter results on tree visits."""
ret = super().visitChildren(node)
if isinstance(ret, list) and len(ret) == 1:
return ret[0]
return ret
[docs]
def aggregateResult(self, aggregate, nextResult):
"""Aggregate results from multiple children into a list."""
ret = aggregate
if nextResult is not None:
if ret is None:
ret = [nextResult]
else:
ret += [nextResult]
return ret