#192 but errors instead of warnings

RELEASENOTES.docu

@@ -1721,4 +1721,11 @@ extern typedef struct { } my_type_t;</pre> </add-note></build-id>
   <build-id value="6205"><add-note> Fixed a bug with how template types were
       handled by DMLC that could cause the compiler to still exhibit
       nondeterministic behaviour.</add-note></build-id>
+  <build-id value="next"><add-note> Added an error if a device declares
+      more than 63 log groups (including the two built-in log groups.)
+  </add-note></build-id>
+  <build-id value="next"><add-note> Added a pair of warnings for if the
+      specified log level of a log statement is likely intended to instead
+      specify the log groups, or vice versa <bug number="22018374443"/>.
+  </add-note></build-id>
 </rn>

doc/1.4/language.md

@@ -2360,6 +2360,9 @@ is similar to a `constant` declaration, but the value is
 allocated automatically so that all log groups are represented by
 distinct powers of 2 and can be combined with bitwise *or*.
 
+A maximum of 63 log groups may be declared per device (61 excluding the built-in
+`Register_Read` and `Register_Write` log groups.)
+
 ### Typedef Declarations
 
 <pre>

py/dml/c_backend.py

@@ -340,13 +340,11 @@ def generate_hfile(device, headers, filename):
     print_device_substruct(device)
 
     if dml.globals.log_groups:
-        out('typedef enum %s_log_group {\n' % crep.cname(device),
-            postindent = 1)
         i = 1
         for g in dml.globals.log_groups:
-            out('%s = %d,\n' % (crep.cloggroup(g), i))
+            out('static const uint64 %s UNUSED = %dULL;\n'
+                % (crep.cloggroup(g), i))
             i <<= 1
-        out('} %s_log_group_t;\n' % crep.cname(device), preindent = -1)
         out('\n')
 
     out('void hard_reset_'+crep.cname(device)

py/dml/codegen.py

@@ -2047,6 +2047,43 @@ def stmt_delete(stmt, location, scope):
     expr = codegen_expression(expr, location, scope)
     return [mkDelete(stmt.site, expr)]
 
+def probable_loggroups_specification(expr):
+    subexprs = [expr]
+    while subexprs:
+        expr = subexprs.pop()
+
+        if (isinstance(expr, LogGroup)
+            or (expr.constant and expr.value == 0)):
+            return True
+
+        if isinstance(expr, Cast):
+            subexprs.append(expr.expr)
+        elif isinstance(expr, (BitOr, BitOr_dml12)):
+            subexprs.extend((expr.lh, expr.rh))
+        elif isinstance(expr, IfExpr):
+            subexprs.extend((expr.texpr, expr.fexpr))
+
+    return False
+
+def probable_loglevel_specification(expr):
+    subexprs = [expr]
+    probable = False
+    while subexprs:
+        expr = subexprs.pop()
+
+        if (isinstance(expr, LogGroup)
+            or (expr.constant and expr.value == 0)):
+            return False
+
+        if expr.constant and 1 <= expr.value <= 5:
+            probable = True
+        elif isinstance(expr, Cast):
+            subexprs.append(expr.expr)
+        elif isinstance(expr, IfExpr):
+            subexprs.extend((expr.texpr, expr.fexpr))
+
+    return probable
+
 log_index = 0
 @statement_dispatcher
 def stmt_log(stmt, location, scope):
@@ -2061,6 +2098,8 @@ def stmt_log(stmt, location, scope):
     if level.constant and not (1 <= level.value <= 4):
         report(ELLEV(level.site, 4))
         level = mkIntegerLiteral(site, 1)
+    elif probable_loggroups_specification(level):
+        report(ELGROUPSASLEV(level.site))
 
     if later_level is not None:
         later_level = ctree.as_int(codegen_expression(
@@ -2071,6 +2110,8 @@ def stmt_log(stmt, location, scope):
         if later_level.constant and not (1 <= later_level.value <= 5):
             report(ELLEV(later_level.site, 5))
             later_level = mkIntegerLiteral(site, 4)
+        elif probable_loggroups_specification(later_level):
+            report(ELGROUPSASLEV(later_level.site))
         global log_index
         table_ptr = TPtr(TNamed("ht_int_table_t"))
         table = mkLit(site, '&(_dev->_subsequent_log_ht)', table_ptr)
@@ -2102,13 +2143,14 @@ def stmt_log(stmt, location, scope):
 
     else:
         pre_statements = []
+
+    groups = ctree.as_int(codegen_expression(groups, location, scope))
+    if probable_loglevel_specification(groups):
+        report(ELLEVASGROUPS(groups.site))
     fmt, args = fix_printf(fmt, args, argsites, site)
     return [mkCompound(site, pre_statements + [
         log_statement(site, location.node, location.indices,
-                      logkind, level,
-                      codegen_expression(groups, location, scope),
-                      fmt, *args)])]
-
+                      logkind, level, groups, fmt, *args)])]
 @statement_dispatcher
 def stmt_try(stmt, location, scope):
     [tryblock, excblock] = stmt.args

py/dml/ctree.py

@@ -66,7 +66,7 @@
     'mkContinue',
     'mkAssignStatement',
     'mkCopyData',
-    'mkIfExpr',
+    'mkIfExpr', 'IfExpr',
     #'BinOp',
     #'Test',
     #'Flag',
@@ -82,7 +82,7 @@
     'mkNotEquals',
     #'BitBinOp',
     'mkBitAnd',
-    'mkBitOr',
+    'mkBitOr', 'BitOr', 'BitOr_dml12',
     'mkBitXOr',
     'BitShift',
     'mkShL',
@@ -145,6 +145,7 @@
     'InvalidSymbol',
     'mkQName', 'QName',
     'mkDeviceObject',
+    'LogGroup',
     'mkStructDefinition',
     'mkDeclaration',
     'mkCText',
@@ -194,6 +195,9 @@ class ExpressionSymbol(symtab.Symbol):
     """A symbol that corresponds to an expression."""
     def __init__(self, name, expr, site):
         super(ExpressionSymbol, self).__init__(name, value = expr, site = site)
+    @property
+    def type(self):
+        return self.value.ctype()
     def expr(self, site):
         expr = self.value.copy(site)
         expr.incref()
@@ -4330,6 +4334,18 @@ def read(self):
 
 mkDeviceObject = DeviceObject
 
+class LogGroup(Expression):
+    type = TInt(64, False, const=True)
+    slots = ('name',)
+    @auto_init
+    def __init__(self, site, name): pass
+
+    def __str__(self):
+        return self.name
+
+    def read(self):
+        return crep.cloggroup(self.name)
+
 class Initializer(object):
     """An initializer is either an expression, or a
     list structure that matches the structure of the data

py/dml/messages.py

@@ -1536,6 +1536,53 @@ class EIDENTSIZEOF(DMLError):
     def __init__(self, site, identifier):
         DMLError.__init__(self, site, identifier, identifier)
 
+class ELOGGROUPS(DMLError):
+    """
+    Too many log groups were declared. A device may have a maximum of 63
+    `loggroup` declarations (61 excluding the built-in `Register_Read` and
+    `Register_Write` loggroups).
+    """
+    fmt = ("Too many loggroup declarations. A maximum of 63 log groups (61 "
+           + "excluding builtins) may be declared per device.")
+
+class ELGROUPSASLEV(DMLError):
+    """
+    The specified log level of a `log` looks as though you meant to specify the
+    log groups instead. For example:
+    ```
+    log info, some_log_group: ...;
+    log info, (some_log_group | another_log_group), 1: ...;
+    ```
+    If you indeed wanted to specify the log groups, make sure to also
+    explicitly specify the log level, and specify it first.
+    ```
+    log info, 1, some_log_group: ...;
+    log info, 1, (some_log_group | another_log_group): ...;
+    ```
+    """
+    fmt = ("the specified log level is likely intended to instead be a log "
+           + "groups specification. "
+           + "In order to specify log groups, the log level must be "
+           + "(explicitly) specified beforehand.")
+
+class ELLEVASGROUPS(DMLError):
+    """
+    The specified log groups of a `log` looks as though you meant to specify
+    the log level instead. For example:
+    ```
+    log info, some_variable, 2: ...;
+    ```
+    If you indeed wanted to specify the log level, specify it before the log
+    groups.
+    ```
+    log info, 2, some_variable: ...;
+    ```
+    """
+    fmt = ("the specified log groups are likely intended to instead be a log "
+           + "level specification. "
+           + "If so, reorder the specifications: the log level must be "
+           + "specified before the log groups.")
+
 #
 # WARNINGS (keep these as few as possible)
 #

py/dml/structure.py

@@ -185,10 +185,11 @@ def mkglobals(stmts):
                 new_typedefs.add(name)
             elif stmt[0] == 'loggroup':
                 _, site, name = stmt
+                if len(dml.globals.log_groups) >= 63:
+                    report(ELOGGROUPS(site))
                 dml.globals.log_groups.append(name)
-                new_symbols.append(LiteralSymbol(
-                    name, TNamed('int', const=True), site,
-                    crep.cloggroup(name)))
+                new_symbols.append(ExpressionSymbol(
+                    name, LogGroup(site, name), site))
             elif stmt.kind != 'constant': # handled above
                 raise ICE(stmt.site, 'bad AST kind: %s' % (stmt.kind,))
         except DMLError as e:

test/1.2/trivial/T_loggroup_1.dml

@@ -5,12 +5,18 @@
 dml 1.2;
 device test;
 import "testing.dml";
+import "dml12-compatibility.dml";
+import "simics/simulator/conf-object.dml";
 
-loggroup lg1;
-loggroup lg2;
-loggroup lg3;
-loggroup lg4;
+loggroup lg1;  loggroup lg2;  loggroup lg3;  loggroup lg4;  loggroup lg5;
+loggroup lg6;  loggroup lg7;  loggroup lg8;  loggroup lg9;  loggroup lg10;
+loggroup lg11; loggroup lg12; loggroup lg13; loggroup lg14; loggroup lg15;
+loggroup lg16; loggroup lg17; loggroup lg18; loggroup lg19; loggroup lg20;
+loggroup lg21; loggroup lg22; loggroup lg23; loggroup lg24; loggroup lg25;
+loggroup lg26; loggroup lg27; loggroup lg28; loggroup lg29; loggroup lg30;
+loggroup lg31; loggroup lg32; loggroup lg33;
 
 method test -> (bool result) {
-    result = ((lg1 == 1) && (lg2 == 2) && (lg3 == 4) && (lg4 == 8));
+    result = ((lg1 == 1) && (lg2 == 2) && (lg3 == 4) && (lg4 == 8)
+              && (lg33 == cast(1 << 32, uint64)));
 }

test/1.4/errors/T_ELGROUPSASLEV.dml

@@ -0,0 +1,32 @@
+/*
+  © 2023 Intel Corporation
+  SPDX-License-Identifier: MPL-2.0
+*/
+dml 1.4;
+device test;
+
+/// COMPILE-ONLY
+
+loggroup lg;
+
+session bool b;
+session int i;
+
+method init() {
+    /// ERROR ELGROUPSASLEV
+    log info, lg: "log";
+    /// ERROR ELGROUPSASLEV
+    log info, lg, i: "log";
+    /// ERROR ELGROUPSASLEV
+    log info, (lg | 0): "log";
+    /// ERROR ELGROUPSASLEV
+    log info, b ? (cast(lg | i, uint32) | i) : i: "log";
+    /// ERROR ELGROUPSASLEV
+    log info, b ? (cast(i | i, uint32) | i) : 0: "log";
+
+    // no warning
+    log info, b ? (cast(1 | i, uint32) | i) : i: "log";
+    log info, lg + 0: "log";
+    local uint64 lg_ = lg;
+    log info, lg_: "log";
+}

test/1.4/errors/T_ELLEVASGROUPS.dml

@@ -0,0 +1,34 @@
+/*
+  © 2023 Intel Corporation
+  SPDX-License-Identifier: MPL-2.0
+*/
+dml 1.4;
+device test;
+
+/// COMPILE-ONLY
+
+loggroup lg;
+
+session bool b;
+session int i;
+
+method init() {
+    // no warning
+    log info, i, lg: "log";
+
+    /// ERROR ELLEVASGROUPS
+    log info, i, 1: "log";
+    /// ERROR ELLEVASGROUPS
+    log info, i, 5: "log";
+    /// ERROR ELLEVASGROUPS
+    log info, i, b ? cast(1, uint32) : i: "log";
+
+    // no warning
+    log info, i, 6: "log";
+    log info, i, b ? cast(1, uint32) : 0: "log";
+    log info, i, b ? cast(1, uint32) : lg: "log";
+    log info, i, b ? cast(i, uint32) : i: "log";
+    log info, i, 1 + i: "log";
+    local uint64 ll_ = 1;
+    log info, i, ll_: "log";
+}

test/1.4/errors/T_ELOGGROUPS.dml

@@ -0,0 +1,24 @@
+/*
+  © 2023 Intel Corporation
+  SPDX-License-Identifier: MPL-2.0
+*/
+dml 1.4;
+device test;
+
+/// ERROR ELOGGROUPS dml-builtins.dml
+
+loggroup lg1;  loggroup lg2;  loggroup lg3;  loggroup lg4;  loggroup lg5;
+loggroup lg6;  loggroup lg7;  loggroup lg8;  loggroup lg9;  loggroup lg10;
+loggroup lg11; loggroup lg12; loggroup lg13; loggroup lg14; loggroup lg15;
+loggroup lg16; loggroup lg17; loggroup lg18; loggroup lg19; loggroup lg20;
+loggroup lg21; loggroup lg22; loggroup lg23; loggroup lg24; loggroup lg25;
+loggroup lg26; loggroup lg27; loggroup lg28; loggroup lg29; loggroup lg30;
+loggroup lg31; loggroup lg32; loggroup lg33; loggroup lg34; loggroup lg35;
+loggroup lg36; loggroup lg37; loggroup lg38; loggroup lg39; loggroup lg40;
+loggroup lg41; loggroup lg42; loggroup lg43; loggroup lg44; loggroup lg45;
+loggroup lg46; loggroup lg47; loggroup lg48; loggroup lg49; loggroup lg50;
+loggroup lg51; loggroup lg52; loggroup lg53; loggroup lg54; loggroup lg55;
+loggroup lg56; loggroup lg57; loggroup lg58; loggroup lg59; loggroup lg60;
+loggroup lg61; loggroup lg62; loggroup lg63;
+/// ERROR ELOGGROUPS
+loggroup lg64;