Fixes to handling of staticness of generics and constants

Fixes #1022

Author: nickg

src/common.c

@@ -1712,7 +1712,7 @@ static bool is_static(tree_t expr)
          tree_t decl = tree_ref(expr);
          switch (tree_kind(decl)) {
          case T_CONST_DECL:
-            return !(tree_flags(decl) & TREE_F_SEQ_BLOCK);
+            return !!(tree_flags(decl) & TREE_F_GLOBALLY_STATIC);
          case T_UNIT_DECL:
          case T_ENUM_LIT:
          case T_GENERIC_DECL:

src/parse.c

@@ -4997,6 +4997,20 @@ static void p_interface_constant_declaration(tree_t parent, tree_kind_t kind,
    if ((mode == PORT_OUT || mode == PORT_INOUT) && !explicit_constant)
       class = C_VARIABLE;
 
+   if (kind == T_GENERIC_DECL) {
+      // In the 2008 standard generics in packages or subprograms are
+      // locally static if they have a locally static subtype
+      switch (tree_kind(parent)) {
+      case T_PACKAGE:
+      case T_FUNC_DECL:
+      case T_PROC_DECL:
+         flags |= TREE_F_LOCALLY_STATIC;
+         break;
+      default:
+         break;
+      }
+   }
+
    type_t type = p_interface_type_indication(parent);
 
    tree_t init = NULL;
@@ -6919,12 +6933,33 @@ static void p_constant_declaration(tree_t parent)
          solve_known_subtype(nametab, init, type);
    }
 
+   // According to the LRM all constants are globally static but that
+   // leads to a number of logical inconsistencies so we retrict to only
+   // constants in certain regions where the value can be computed
+   // during elaboration
+   tree_flags_t flags = 0;
+   switch (tree_kind(parent)) {
+   case T_ENTITY:
+   case T_ARCH:
+   case T_PACKAGE:
+   case T_PACK_BODY:
+   case T_BLOCK:
+   case T_FOR_GENERATE:
+   case T_COND_STMT:     // If-generate
+   case T_ALTERNATIVE:   // For-generate
+      flags |= TREE_F_GLOBALLY_STATIC;
+      break;
+   default:
+      break;
+   }
+
    consume(tSEMI);
 
    for (ident_list_t *it = ids; it != NULL; it = it->next) {
       tree_t t = tree_new(T_CONST_DECL);
       tree_set_ident(t, it->ident);
       tree_set_type(t, type);
+      tree_set_flag(t, flags);
       tree_set_loc(t, &(it->loc));
       if (init != NULL)
          tree_set_value(t, init);

src/sem.c

@@ -970,6 +970,18 @@ static bool sem_check_const_decl(tree_t t, nametab_t *tab)
 
       if (fwd == NULL)
          sem_propagate_constraints(t, value);
+
+      // A constant with a globaly static value should be treated as
+      // globally static regardless of where it is declared
+      if (sem_globally_static(value)) {
+         tree_set_flag(t, TREE_F_GLOBALLY_STATIC);
+
+         // A reference to a constant with a locally static subype and
+         // locally static value is locally static
+         if (sem_locally_static(value)
+             && sem_static_subtype(tree_type(t), sem_locally_static))
+            tree_set_flag(t, TREE_F_LOCALLY_STATIC);
+      }
    }
    else if (tree_kind(find_enclosing(tab, S_DESIGN_UNIT)) != T_PACKAGE)
       sem_error(t, "deferred constant declarations are only permitted "
@@ -1447,6 +1459,13 @@ static bool sem_check_generic_decl(tree_t t, nametab_t *tab)
                    type_pp(type));
    }
 
+   if (tree_flags(t) & TREE_F_LOCALLY_STATIC) {
+      // For a generic declaration in a pacakage or subprogram to be
+      // locally static it must also have a locally static subtype
+      if (!sem_static_subtype(type, sem_locally_static))
+         tree_clear_flag(t, TREE_F_LOCALLY_STATIC);
+   }
+
    return true;
 }
 
@@ -5530,20 +5549,17 @@ static bool sem_locally_static(tree_t t)
 
       // A constant reference (other than a deferred constant) with a
       // locally static value
-      if (dkind == T_CONST_DECL) {
-         if (tree_has_value(decl))
-            return sem_locally_static(tree_value(decl));
-         else
-            return false;
-      }
+      if (dkind == T_CONST_DECL && (tree_flags(decl) & TREE_F_LOCALLY_STATIC))
+         return true;
 
       // An alias of a locally static name
       if (dkind == T_ALIAS)
          return sem_locally_static(tree_value(decl));
 
-      // [2008] A generic reference with a locally static subtype
-      if (dkind == T_GENERIC_DECL && (standard() >= STD_08 || relaxed_rules()))
-         return sem_static_subtype(tree_type(decl), sem_locally_static);
+      // [2008] A formal generic constant of a generic-mapped subprogram
+      // or package with a locally static subtype
+      if (dkind == T_GENERIC_DECL && (tree_flags(decl) & TREE_F_LOCALLY_STATIC))
+         return true;
    }
 
    // A locally static range
@@ -5794,8 +5810,16 @@ static bool sem_globally_static(tree_t t)
 
    if (kind == T_REF) {
       tree_t decl = tree_ref(t);
-      const tree_kind_t decl_kind = tree_kind(decl);
-      return decl_kind == T_GENERIC_DECL || decl_kind == T_CONST_DECL;
+      switch (tree_kind(decl)) {
+      case T_GENERIC_DECL:
+         return true;
+      case T_CONST_DECL:
+         // Do not treat all constants as globally static, this is a
+         // defect in the LRM
+         return !!(tree_flags(decl) & TREE_F_GLOBALLY_STATIC);
+      default:
+         return false;
+      }
    }
    else if (kind == T_EXTERNAL_NAME)
       return tree_class(t) == C_CONSTANT;
@@ -7157,20 +7181,6 @@ static bool sem_check_cond_value(tree_t t, nametab_t *tab)
    return true;
 }
 
-static bool sem_check_sequence(tree_t t, nametab_t *tab)
-{
-   const int ndecls = tree_decls(t);
-   for (int i = 0; i < ndecls; i++) {
-      // Mark all constant declarations as they need to be treated
-      // specially when calculating longest static prefix
-      tree_t d = tree_decl(t, i);
-      if (tree_kind(d) == T_CONST_DECL)
-         tree_set_flag(d, TREE_F_SEQ_BLOCK);
-   }
-
-   return true;
-}
-
 static bool sem_check_prot_decl(tree_t t, nametab_t *tab)
 {
    const int ndecls = tree_decls(t);
@@ -7349,6 +7359,7 @@ bool sem_check(tree_t t, nametab_t *tab)
    case T_BOX:
    case T_PSL:
    case T_LOOP:
+   case T_SEQUENCE:
       return true;
    case T_CONV_FUNC:
       return sem_check_conv_func(t, tab);
@@ -7374,8 +7385,6 @@ bool sem_check(tree_t t, nametab_t *tab)
       return sem_check_view_decl(t, tab);
    case T_COND_VALUE:
       return sem_check_cond_value(t, tab);
-   case T_SEQUENCE:
-      return sem_check_sequence(t, tab);
    case T_PROT_DECL:
       return sem_check_prot_decl(t, tab);
    case T_INERTIAL:

src/tree.h

@@ -422,7 +422,6 @@ typedef enum {
    TREE_F_IMPURE_FILE     = (1 << 22),
    TREE_F_IMPURE_SHARED   = (1 << 23),
    TREE_F_CALL_NO_ARGS    = (1 << 24),
-   TREE_F_SEQ_BLOCK       = (1 << 25),
 } tree_flags_t;
 
 typedef enum {

test/sem/issue105.vhd

@@ -9,7 +9,7 @@ begin
     process (x) is
     begin
         case x is
-            when GEN =>                 -- OK in 2008
+            when GEN =>                 -- Error (used to be allowed)
                 report "x = GEN";
             when others =>
                 report "x /= GEN";

test/sem/static.vhd

@@ -115,4 +115,11 @@ begin
         end case;
     end process;
 
+    p4: process is
+        constant N1 : integer := N + 1;
+        variable v : bit_vector(7 downto 0);
+        alias a is v(N1 downto 0);      -- OK
+    begin
+    end process;
+
 end architecture;

test/test_sem.c

@@ -1316,11 +1316,17 @@ START_TEST(test_issue105)
 {
    set_standard(STD_08);
 
+   const error_t expect[] = {
+      { 12, "case choice must be locally static" },
+      { -1, NULL }
+   };
+   expect_errors(expect);
+
    input_from_file(TESTDIR "/sem/issue105.vhd");
 
    parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH);
 
-   fail_if_errors();
+   check_expected_errors();
 }
 END_TEST