"""Validate source information that is lost when lowering to the metamodel.
Rules follow the analyzer in the source bundle of MINRES CoreDSL 2.0.21.
The semantic pass handles known integer/array types and scoped ISA parameters.
Remaining elaboration and provider gaps are tracked in the parity map.
"""
import logging
from contextlib import contextmanager
from ...diagnostics import M2ValidationError
from ...metamodel.code_info import LineInfoFactory
from ...warnings import WarningsManager
from .constant_expressions import constant_value, integer_value, integer_literal
from .parser_gen import CoreDSL2Parser as P, CoreDSL2Visitor
[docs]
logger = logging.getLogger("validate_source")
# CoreDslAnalyzer.attributeRegistry in the 2.0.21 source bundle. Parameter
# count errors intentionally share InvalidAttributePlacement upstream.
[docs]
ATTRIBUTES = {
"enable": ("instruction", 1),
"hls": ("instruction", 0),
"no_cont": ("instruction", 0),
"cond": ("instruction", 0),
"flush": ("instruction", 0),
"type": ("instruction", 1),
"expected_encoding_size": ("instruction", 1),
"do_not_synthesize": ("function", 0),
"clk_budget": ("function", 1),
"uses_mem": ("function", 0),
"is_pc": ("declarator", 0),
"is_main_reg": ("declarator", 0),
"is_main_mem": ("declarator", 0),
"is_interlock_for": ("declarator", 1),
# TODO: add M2-ISA-R specific attrs here automatically?
}
[docs]
def location(ctx):
return LineInfoFactory.make(
ctx.start.source[1].fileName, ctx.start.start, ctx.stop.stop, ctx.start.line, ctx.stop.line
)
[docs]
def unresolved(ctx, kind, name):
"""The release's linking diagnostic for a name that does not resolve."""
return M2ValidationError(
f"Couldn't resolve reference to {kind} '{name}'.", "org.eclipse.xtext.diagnostics.Diagnostic.Linking", location(ctx)
)
[docs]
class Diagnostics(list):
"""Validation errors reported together: the first is raised, the rest are attached to it."""
[docs]
def add(self, ctx, issue, message):
self.append(M2ValidationError(message, issue, location(ctx)))
@contextmanager
[docs]
def collect(self):
"""Record a validation error raised in the block instead of propagating it."""
try:
yield
except M2ValidationError as error:
self.append(error)
[docs]
def raise_if_any(self):
if self:
self[0].related_diagnostics.extend(self[1:])
raise self[0]
[docs]
class ScopeStack:
"""Lexical scopes in ``self.scopes``: name -> entity dicts, innermost last."""
@contextmanager
[docs]
def scope(self, names=None):
self.scopes.append({} if names is None else names)
try:
yield
finally:
self.scopes.pop()
@contextmanager
[docs]
def only_scopes(self, scopes):
"""Replace the whole scope stack for the block."""
earlier, self.scopes = self.scopes, scopes
try:
yield
finally:
self.scopes = earlier
@contextmanager
[docs]
def in_progress(active, key):
"""Mark ``key`` active for the block; yield whether it already was (a cycle)."""
if key in active:
yield True
return
active.add(key)
try:
yield False
finally:
active.remove(key)
[docs]
def dependencies(definition):
"""Names of the instruction sets a core or instruction set builds on."""
if isinstance(definition, P.Instruction_setContext):
return [*definition.extension, *definition.combines]
return definition.contributing_types
[docs]
def contributors(definitions, root):
"""``root`` and every definition it builds on, each once, dependencies first."""
result, seen = [], set()
def visit(ctx):
if ctx.name.text in seen:
return
seen.add(ctx.name.text)
for dependency in dependencies(ctx):
if dependency.text in definitions:
visit(definitions[dependency.text])
result.append(ctx)
visit(root)
return result
[docs]
def provided(definitions, starts):
"""``starts`` and the definitions they build on, each once, in lookup precedence order."""
result, seen = [], set()
def visit(ctx):
if ctx.name.text in seen:
return
seen.add(ctx.name.text)
result.append(ctx)
for dependency in dependencies(ctx):
if dependency.text in definitions:
visit(definitions[dependency.text])
for start in starts:
visit(start)
return result
[docs]
def is_const(declaration):
return any(q.getText() == "const" for q in declaration.qualifiers)
[docs]
def is_alias(type_specifier):
return type_specifier.ptr is not None and type_specifier.ptr.text == "&"
[docs]
def return_terminated(ctx):
if isinstance(ctx, P.Block_statementContext):
return return_terminated(ctx.block())
if isinstance(ctx, P.BlockContext):
return bool(ctx.items) and return_terminated(ctx.items[-1])
if isinstance(ctx, P.Block_itemContext):
return ctx.statement() is not None and return_terminated(ctx.statement())
if isinstance(ctx, P.If_statementContext):
return len(ctx.stmt) > len(ctx.cond) and all(return_terminated(stmt) for stmt in ctx.stmt)
return isinstance(ctx, P.Return_statementContext)
[docs]
def statement_expression(ctx):
# Parentheses do not make an expression into a valid statement in MINRES.
return isinstance(
ctx,
(P.Assignment_expressionContext, P.Method_callContext, P.Preinc_expressionContext, P.Postinc_expressionContext),
)
[docs]
class SourceValidator(CoreDSL2Visitor, WarningsManager):
def __init__(self, warnings_info):
CoreDSL2Visitor.__init__(self)
WarningsManager.__init__(self, warnings_info)
@staticmethod
[docs]
def error(ctx, issue, message):
raise M2ValidationError(message, issue, location(ctx))
[docs]
def warning(self, ctx, name, message):
self.emit_warning(message, name, logger, location(ctx))
[docs]
def constant(self, ctx):
try:
return constant_value(ctx)
except ZeroDivisionError:
self.error(ctx, "DivisionByZero", "Division by zero")
except ValueError as exc:
self.error(ctx, "org.eclipse.xtext.diagnostics.Diagnostic.Syntax", str(exc))
[docs]
def visitInteger_type(self, ctx):
if ctx.size is not None:
width = self.constant(ctx.size)
if width is not None and width <= 0:
self.error(ctx, "InvalidIntegerTypeSize", "Integer type size must be greater than 0")
if width is not None and width > 2147483647:
self.error(ctx, "InvalidIntegerTypeSize", "Integer type size must not exceed Integer.MAX_VALUE")
return self.visitChildren(ctx)
[docs]
def visitAttribute(self, ctx):
owner = ctx.parentCtx
if isinstance(owner, (P.InstructionContext, P.Section_instructionsContext)):
usage = "instruction"
elif isinstance(owner, P.Function_definitionContext):
usage = "function"
elif isinstance(owner, (P.DeclarationContext, P.DeclaratorContext)):
usage = "declarator"
else:
usage = "alwaysBlock"
name = ctx.name.text
rule = ATTRIBUTES.get(name)
if rule is None:
self.warning(ctx, "unknown-attribute", f"Unknown attribute '{name}'")
else:
allowed, count = rule
if usage != allowed:
self.error(ctx, "InvalidAttributePlacement", f"Attribute '{name}' cannot be placed here")
if len(ctx.params) != count:
count_string = "1 parameter" if count == 1 else f"{count} parameters"
self.error(
ctx,
"InvalidAttributePlacement",
f"Attribute '{name}' requires exactly {count_string}, but got {len(ctx.params)}",
)
if name == "expected_encoding_size":
expected = self.constant(ctx.params[0])
instructions = (
[owner]
if isinstance(owner, P.InstructionContext)
else [
instruction
for instruction in owner.instructions
if not any(attribute.name.text == name for attribute in instruction.attributes)
]
)
for instruction in instructions:
actual = self.encoding_size(instruction)
if expected is not None and actual is not None and actual != expected:
self.warning(
instruction,
"unexpected-instruction-size",
f"Expected an encoding size of {expected}, but got {actual}",
)
return self.visitChildren(ctx)
[docs]
def encoding_size(self, instruction):
try:
return self._encoding_size(instruction)
except ValueError as exc:
self.error(instruction, "org.eclipse.xtext.diagnostics.Diagnostic.Syntax", str(exc))
[docs]
def _encoding_size(self, instruction):
total = 0
for entry in instruction.encoding:
if isinstance(entry, P.Bit_fieldContext):
left, right = integer_value(entry.left.getText()), integer_value(entry.right.getText())
if not (0 <= left <= 2147483647 and 0 <= right <= 2147483647):
self.error(entry, "IndexOutOfRange", "Index out of range")
total += abs(left - right) + 1
else:
total += integer_literal(entry.value.getText())[1]
return total
[docs]
def visitInstruction(self, ctx):
self.encoding_size(ctx)
return self.visitChildren(ctx)
[docs]
def visitFunction_definition(self, ctx):
if ctx.extern is None and ctx.behavior is None:
self.error(ctx, "MissingFunctionBody", "Non-extern function declaration must specify an implementation")
previous = self.function
self.function = ctx
try:
self.visitChildren(ctx)
finally:
self.function = previous
[docs]
def visitParameter_declaration(self, ctx):
if is_alias(ctx.type_):
self.error(ctx, "ReferenceParameterDeclaration", "Function parameters may not be passed by reference")
if ctx.type_.getText() == "void":
self.error(ctx, "VoidDeclaration", "Declarations may not use type void")
return self.visitChildren(ctx)
[docs]
def visitEnumerator(self, ctx):
if ctx.init is not None and ctx.init.expr is None:
self.error(ctx.init, "InvalidListInitializer", "Enum members must not use list initializers")
return self.visitChildren(ctx)
[docs]
def visitDeclaration(self, ctx):
if isinstance(ctx.parentCtx, P.Composite_definitionContext):
# Release elaboration checks field types, but skips ordinary
# variable declaration checks. MultiDeclaration forbids initializers.
for member in ctx.declarations:
if member.init is not None:
self.error(
member.init,
"org.eclipse.xtext.diagnostics.Diagnostic.Syntax",
"Composite field declarations may not specify an initializer",
)
return self.visitChildren(ctx)
qualifiers = [q.getText() for q in ctx.qualifiers]
storage = [s.getText() for s in ctx.storage]
isa = isinstance(ctx.parentCtx, P.Section_arch_stateContext)
if isa and ctx.type_.getText() == "void":
self.error(ctx, "VoidDeclaration", "Declarations may not use type void")
if isa and len(set(qualifiers)) != len(qualifiers):
self.error(ctx, "DuplicateQualifier", "Duplicate qualifier")
if isa and len(storage) > 1:
self.error(
ctx, "MultipleStorageClassSpecifiers", "A declaration may not specify more than one storage class"
)
# Unqualified non-alias ISA declarations are parameters, including const.
alias = is_alias(ctx.type_)
parameter = isa and bool(ctx.declarations) and not storage and not alias
if parameter:
if not isinstance(ctx.type_.type_, (P.Integer_typeContext, P.Bool_typeContext)):
self.error(
ctx,
"InvalidIsaParameterType",
"ISA parameters may only have integer types (signed, unsigned, bool)",
)
if "volatile" in qualifiers:
self.error(ctx, "InvalidIsaParameterDeclaration", "ISA parameters may not be declared as volatile")
for decl in ctx.declarations:
for dimension in decl.size:
size = self.constant(dimension)
if size is not None and size < 0:
self.error(dimension, "InvalidArraySize", "Negative array size is invalid")
if size == 0:
self.warning(decl, "array-size-zero", "Array size is zero")
if size is not None and size > 2147483647 and "extern" not in storage:
self.warning(decl, "invalid-array-size", "Array size is greater than Integer.MAX_VALUE")
if parameter and "const" not in qualifiers and decl.size:
self.error(decl, "InvalidIsaParameterDeclaration", "An ISA parameter may not be declared as an array")
if any(s in ("extern", "register") for s in storage) and len(decl.size) > 1:
self.error(
decl.size[-2], "MultidimensionalAddressSpace", "Multidimensional address spaces are not allowed"
)
if isa and alias and decl.init is None:
self.error(decl, "UninitializedAlias", "An identifier declared as alias must be initialized")
if isa and alias and decl.init.expr is None:
self.error(
decl, "InvalidListInitializer", "An identifier declared as alias must not use a list initializer"
)
if (
isa
and "const" in qualifiers
and decl.init is None
and not isinstance(ctx.parentCtx, P.Composite_definitionContext)
and not any(s in ("extern", "register") for s in storage)
):
self.error(decl, "UninitializedConstant", "An identifier declared as const must be initialized")
return self.visitChildren(ctx)
[docs]
def visitBlock(self, ctx):
unreachable = False
for item in ctx.items:
self.visit(item)
if unreachable:
self.warning(item, "unreachable-code", "Unreachable code")
if return_terminated(item):
unreachable = True
[docs]
def visitReturn_statement(self, ctx):
return self.visitChildren(ctx)
[docs]
def visitBreak_statement(self, ctx):
if not (self.loop_depth or self.switch_depth):
self.error(ctx, "StrayControlFlowStatement", "Unexpected break statement")
[docs]
def visitContinue_statement(self, ctx):
if not self.loop_depth:
self.error(ctx, "StrayControlFlowStatement", "Unexpected continue statement")
[docs]
def visit_loop(self, ctx):
condition = ctx.cond.end_expr if isinstance(ctx, P.For_statementContext) else ctx.cond
if condition is not None:
self.check_condition(condition)
self.loop_depth += 1
try:
return self.visitChildren(ctx)
finally:
self.loop_depth -= 1
[docs]
visitFor_statement = visit_loop
[docs]
visitWhile_statement = visit_loop
[docs]
visitDo_statement = visit_loop
[docs]
def visitSwitch_statement(self, ctx):
self.switch_depth += 1
try:
return self.visitChildren(ctx)
finally:
self.switch_depth -= 1
[docs]
def visitSpawn_statement(self, ctx):
parent = ctx.parentCtx
direct = isinstance(parent, P.InstructionContext) and parent.behavior is ctx
if isinstance(parent, P.Block_itemContext):
block = parent.parentCtx
block_stmt = block.parentCtx
instruction = block_stmt.parentCtx
direct = (
isinstance(instruction, P.InstructionContext)
and instruction.behavior is block_stmt
and block.items[-1] is parent
)
if not direct:
self.error(
ctx,
"InvalidSpawnStatementPlacement",
"A spawn statement must be the last statement of an instruction's behavior block",
)
return self.visitChildren(ctx)
[docs]
def visitExpression_statement(self, ctx):
# The semantic pass must inspect the expression before checking whether
# it can be a statement, so child diagnostics are not lost.
return self.visitChildren(ctx)
[docs]
def visitFor_condition(self, ctx):
return self.visitChildren(ctx)
[docs]
def check_condition(self, expr):
if isinstance(expr, P.Assignment_expressionContext) and expr.bop.text == "=":
self.warning(expr, "likely-accidental-assignment", "Likely accidental assignment")
[docs]
def visitIf_statement(self, ctx):
for cond in ctx.cond:
self.check_condition(cond)
return self.visitChildren(ctx)
[docs]
def validate_source(tree, warnings_info, parameter_values=None):
try:
_validate_source(tree, warnings_info, parameter_values)
except M2ValidationError as error:
if error.issue_code in (
"com.minres.coredsl.DivisionByZero",
"com.minres.coredsl.InvalidConstantExpressionNode",
"com.minres.coredsl.InvalidConstantExpressionIdentifier",
"com.minres.coredsl.UnsupportedLanguageFeature",
"com.minres.coredsl.InvalidArraySize",
"com.minres.coredsl.MultidimensionalAddressSpace",
"com.minres.coredsl.UnassignedIsaParameter",
"com.minres.coredsl.InvalidIntegerTypeSize",
):
from .source_semantics import invalid_elaboration_summaries
for diagnostic in invalid_elaboration_summaries(tree, parameter_values):
def already_reported(existing):
primary, related = existing.line_info, diagnostic.line_info
same_location = (
primary is not None
and related is not None
and primary.file_path == related.file_path
and primary.start_chr <= related.stop_chr
and related.start_chr <= primary.stop_chr
)
return (diagnostic.issue_code == existing.issue_code and same_location) or any(
already_reported(child) for child in existing.related_diagnostics
)
if already_reported(error):
continue
error.related_diagnostics.append(diagnostic)
raise
[docs]
def _validate_source(tree, warnings_info, parameter_values=None):
validator = SourceValidator(warnings_info)
definitions = {ctx.name.text: ctx for ctx in tree.definitions if isinstance(ctx, P.Instruction_setContext)}
linking_errors = Diagnostics()
for definition in tree.definitions:
for dependency in dependencies(definition):
if dependency.text not in definitions:
linking_errors.append(unresolved(definition, "InstructionSet", dependency.text))
from .source_linking import NameLinker
with linking_errors.collect():
NameLinker(tree).validate(tree)
linking_errors.raise_if_any()
cycle_errors = Diagnostics()
for root in definitions:
stack, visited = [], set()
def check_inheritance(name):
if name in stack:
if name == root:
chain = stack[stack.index(name) :] + [name]
cycle_errors.append(
M2ValidationError(
"Cyclic instruction set inheritance: " + " -> ".join(chain),
"CyclicInstructionSetInheritance",
location(definitions[root]),
)
)
return
if name in visited:
return
visited.add(name)
stack.append(name)
ctx = definitions[name]
for dependency in [*ctx.extension, *ctx.combines]:
check_inheritance(dependency.text)
stack.pop()
check_inheritance(root)
cycle_errors.raise_if_any()
validator.visit(tree)
from .source_semantics import validate_semantics
validate_semantics(tree, warnings_info, parameter_values)