Now handle vhdl 2008 arrays in the front end.

Bug fixes.

1 files changed, 820 insertions, 376 deletions

diff --git a/sem_types.adb b/sem_types.adb
index fc8b932ed..4b54dd4d9 100644
--- a/sem_types.adb
+++ b/sem_types.adb
@@ -25,6 +25,7 @@ with Sem_Expr; use Sem_Expr;
 with Sem_Scopes; use Sem_Scopes;
 with Sem_Names; use Sem_Names;
 with Sem_Decls;
+with Name_Table;
 with Std_Names;
 with Iirs_Utils; use Iirs_Utils;
 with Std_Package; use Std_Package;
@@ -78,12 +79,14 @@ package body Sem_Types is
             Set_Type_Has_Signal (Get_Element_Subtype (Atype));
          when Iir_Kind_Record_Type_Definition =>
             declare
+               El_List : constant Iir_List :=
+                 Get_Elements_Declaration_List (Atype);
                El : Iir;
             begin
-               El := Get_Element_Declaration_Chain (Atype);
-               while El /= Null_Iir loop
+               for I in Natural loop
+                  El := Get_Nth_Element (El_List, I);
+                  exit when El = Null_Iir;
                   Set_Type_Has_Signal (Get_Type (El));
-                  El := Get_Chain (El);
                end loop;
             end;
          when Iir_Kind_Error =>
@@ -452,7 +455,9 @@ package body Sem_Types is
       --  array subtype] [...] for the element subtype indication
       --  of an array type definition, if the type of the array
       --  element is itself an array type.
-      if not Sem_Is_Constrained (El_Type) then
+      if Vhdl_Std < Vhdl_08
+        and then not Is_Fully_Constrained_Type (El_Type)
+      then
          Error_Msg_Sem ("array element of unconstrained "
                         & Disp_Node (El_Type) & " is not allowed", Def);
       end if;
@@ -655,6 +660,62 @@ package body Sem_Types is
       Close_Declarative_Region;
    end Sem_Protected_Type_Body;
 
+
+   --  Return the constraint state from CONST (the initial state) and ATYPE,
+   --  as if ATYPE was a new element of a record.
+   function Update_Record_Constraint (Const : Iir_Constraint; Atype : Iir)
+                                     return Iir_Constraint is
+   begin
+      if Get_Kind (Atype) not in Iir_Kinds_Composite_Type_Definition then
+         return Const;
+      end if;
+
+      case Const is
+         when Fully_Constrained
+           | Unconstrained =>
+            if Get_Constraint_State (Atype) = Const then
+               return Const;
+            else
+               return Partially_Constrained;
+            end if;
+         when Partially_Constrained =>
+            return Partially_Constrained;
+      end case;
+   end Update_Record_Constraint;
+
+   function Get_Array_Constraint (Def : Iir) return Iir_Constraint
+   is
+      El_Type : constant Iir := Get_Element_Subtype (Def);
+      Index : constant Boolean :=
+        Get_Kind (Def) = Iir_Kind_Array_Subtype_Definition
+        and then Get_Index_Constraint_Flag (Def);
+   begin
+      if Get_Kind (El_Type) in Iir_Kinds_Composite_Type_Definition then
+         case Get_Constraint_State (El_Type) is
+            when Fully_Constrained =>
+               if Index then
+                  return Fully_Constrained;
+               else
+                  return Partially_Constrained;
+               end if;
+            when Partially_Constrained =>
+               return Partially_Constrained;
+            when Unconstrained =>
+               if not Index then
+                  return Unconstrained;
+               else
+                  return Partially_Constrained;
+               end if;
+         end case;
+      else
+         if Index then
+            return Fully_Constrained;
+         else
+            return Unconstrained;
+         end if;
+      end if;
+   end Get_Array_Constraint;
+
    function Sem_Type_Definition (Def: Iir; Decl: Iir) return Iir
    is
    begin
@@ -670,6 +731,7 @@ package body Sem_Types is
             declare
                El: Iir;
                Literal_List: Iir_List;
+               Only_Characters : Boolean := True;
             begin
                Literal_List := Get_Enumeration_Literal_List (Def);
                for I in Natural loop
@@ -684,7 +746,13 @@ package body Sem_Types is
                   Sem_Scopes.Add_Name (El);
                   Name_Visible (El);
                   Xref_Decl (El);
+                  if Only_Characters
+                    and then not Name_Table.Is_Character (Get_Identifier (El))
+                  then
+                     Only_Characters := False;
+                  end if;
                end loop;
+               Set_Only_Characters_Flag (Def, Only_Characters);
             end;
             Set_Resolved_Flag (Def, False);
             return Def;
@@ -716,6 +784,25 @@ package body Sem_Types is
             end;
 
          when Iir_Kind_Array_Subtype_Definition =>
+            --  LRM08 5.3.2.1  Array types
+            --  A constrained array definition similarly defines both an array
+            --  type and a subtype of this type.
+            --  - The array type is an implicitely declared anonymous type,
+            --    this type is defined by an (implicit) unbounded array
+            --    definition in which the element subtype indication either
+            --    denotes the base type of the subtype denoted by the element
+            --    subtype indication of the constrained array definition, if
+            --    that subtype is a composite type, or otherwise is the
+            --    element subtype indication of the constrained array
+            --    definition, and in which the type mark of each index subtype
+            --    definition denotes the subtype defined by the corresponding
+            --    discrete range.
+            --  - The array subtype is the subtype obtained by imposition of
+            --    the index constraint on the array type and if the element
+            --    subtype indication of the constrained array definition
+            --    denotes a fully or partially constrained composite subtype,
+            --    imposition of the constraint of that subtype as an array
+            --    element constraint on the array type.
             declare
                Index_Type : Iir;
                Index_List : Iir_List;
@@ -773,7 +860,10 @@ package body Sem_Types is
                Set_Type_Staticness (Base_Type, None);
                Set_Type_Declarator (Base_Type, Decl);
                Set_Resolved_Flag (Base_Type, Get_Resolved_Flag (Def));
-
+               Set_Index_Constraint_Flag (Def, True);
+               Set_Constraint_State (Def, Get_Array_Constraint (Def));
+               Set_Constraint_State
+                 (Base_Type, Get_Array_Constraint (Base_Type));
                Set_Base_Type (Def, Base_Type);
                Set_Type_Mark (Def, Base_Type);
                return Def;
@@ -811,38 +901,39 @@ package body Sem_Types is
                --  According to LRM93 §7.4.1, an unconstrained array type
                --  is not static.
                Set_Type_Staticness (Def, None);
-
                Sem_Array_Element (Def);
+               Set_Constraint_State (Def, Get_Array_Constraint (Def));
                return Def;
             end;
 
          when Iir_Kind_Record_Type_Definition =>
             declare
-               --  Non semantized type of previous element.
-               Last_El_Type : Iir;
                --  Semantized type of previous element
                Last_Type : Iir;
 
+               El_List : Iir_List;
                El: Iir;
                El_Type : Iir;
                Resolved_Flag : Boolean;
                Staticness : Iir_Staticness;
+               Constraint : Iir_Constraint;
             begin
                --  LRM 10.1
                --  5. A record type declaration,
                Open_Declarative_Region;
 
                Resolved_Flag := True;
-               Last_El_Type := Null_Iir;
                Last_Type := Null_Iir;
                Staticness := Locally;
+               Constraint := Fully_Constrained;
                Set_Signal_Type_Flag (Def, True);
-               El := Get_Element_Declaration_Chain (Def);
-               while El /= Null_Iir loop
+               El_List := Get_Elements_Declaration_List (Def);
+               for I in Natural loop
+                  El := Get_Nth_Element (El_List, I);
+                  exit when El = Null_Iir;
                   El_Type := Get_Type (El);
-                  if El_Type /= Last_El_Type then
+                  if El_Type /= Null_Iir then
                      --  Be careful for a declaration list (r,g,b: integer).
-                     Last_El_Type := El_Type;
                      El_Type := Sem_Subtype_Indication (El_Type);
                      Last_Type := El_Type;
                   else
@@ -860,7 +951,9 @@ package body Sem_Types is
                      --  subtype] exits for the subtype indication of an
                      --  element declaration, if the type of the record
                      --  element is an array type.
-                     if not Sem_Is_Constrained (El_Type) then
+                     if Vhdl_Std < Vhdl_08
+                       and then not Is_Fully_Constrained_Type (El_Type)
+                     then
                         Error_Msg_Sem
                           ("element declaration of unconstrained "
                            & Disp_Node (El_Type) & " is not allowed", El);
@@ -869,18 +962,20 @@ package body Sem_Types is
                        Resolved_Flag and Get_Resolved_Flag (El_Type);
                      Staticness := Min (Staticness,
                                         Get_Type_Staticness (El_Type));
+                     Constraint := Update_Record_Constraint
+                       (Constraint, El_Type);
                   else
                      Staticness := None;
                   end if;
                   Sem_Scopes.Add_Name (El);
                   Name_Visible (El);
                   Xref_Decl (El);
-                  El := Get_Chain (El);
                end loop;
                Close_Declarative_Region;
                Set_Base_Type (Def, Def);
                Set_Resolved_Flag (Def, Resolved_Flag);
                Set_Type_Staticness (Def, Staticness);
+               Set_Constraint_State (Def, Constraint);
                return Def;
             end;
 
@@ -1055,28 +1150,14 @@ package body Sem_Types is
    end Is_A_Resolution_Function;
 
    --  Note: this sets resolved_flag.
-   procedure Sem_Resolution_Function (Decl: Iir)
+   procedure Sem_Resolution_Function (Name : Iir; Atype : Iir)
    is
-      Func: Iir;
-      Name : Iir;
+      Func : Iir;
       Res: Iir;
       El : Iir;
       List : Iir_List;
       Has_Error : Boolean;
    begin
-      Name := Get_Resolution_Function (Decl);
-      if Name = Null_Iir then
-         -- This is not a resolved type.
-         return;
-      end if;
-
-      -- FIXME: add this check (maybe based on resolved_flag ?)
-      --if Get_Kind (Name) in Iir_Kinds_Function_Declaration then
-      --   --  The resolution function was already semantized.
-      --   --  This can happen if comes from an unconstrained array subtype.
-      --   return;
-      --end if;
-
       Sem_Name (Name, False);
       Func := Get_Named_Entity (Name);
       if Func = Error_Mark then
@@ -1091,14 +1172,14 @@ package body Sem_Types is
          for I in Natural loop
             El := Get_Nth_Element (List, I);
             exit when El = Null_Iir;
-            if Is_A_Resolution_Function (El, Decl) then
+            if Is_A_Resolution_Function (El, Atype) then
                if Res /= Null_Iir then
                   if not Has_Error then
                      Has_Error := True;
                      Error_Msg_Sem
                        ("can't resolve overload for resolution function",
-                        Decl);
-                     Error_Msg_Sem ("candidate functions are:", Decl);
+                        Atype);
+                     Error_Msg_Sem ("candidate functions are:", Atype);
                      Error_Msg_Sem (" " & Disp_Subprg (Func), Func);
                   end if;
                   Error_Msg_Sem (" " & Disp_Subprg (El), El);
@@ -1111,369 +1192,623 @@ package body Sem_Types is
             return;
          end if;
       else
-         if Is_A_Resolution_Function (Func, Decl) then
+         if Is_A_Resolution_Function (Func, Atype) then
             Res := Func;
          end if;
       end if;
 
       if Res = Null_Iir then
          Error_Msg_Sem ("no matching resolution function for "
-                        & Disp_Node (Name), Decl);
+                        & Disp_Node (Name), Atype);
       else
          Set_Named_Entity (Name, Res);
          Set_Use_Flag (Res, True);
-         Set_Resolved_Flag (Decl, True);
+         Set_Resolved_Flag (Atype, True);
+         Set_Resolution_Function (Atype, Name);
          Xref_Name (Name);
       end if;
    end Sem_Resolution_Function;
 
-   --  Semantize array_subtype_definition DEF using TYPE_MARK as the base type
-   --  of DEF.
-   --  DEF must have an index list and may have a resolution function.
-   --  Return DEF.
-   function Sem_Array_Subtype_Indication (Type_Mark : Iir; Def : Iir)
-     return Iir
+   function Sem_Subtype_Constraint
+     (Def : Iir; Type_Mark : Iir; Resolution : Iir)
+     return Iir;
+
+   -- DEF is an incomplete subtype_indication or array_constraint,
+   -- BASE_TYPE is the base type of the subtype_indication.
+   function Sem_Array_Constraint (Def : Iir; Type_Mark : Iir; Resolution : Iir)
+                                 return Iir
    is
+      Res : Iir;
       Type_Index, Subtype_Index: Iir;
       Base_Type : Iir;
+      Mark_El_Type : Iir;
       El_Type : Iir;
       Staticness : Iir_Staticness;
       Error_Seen : Boolean;
       Type_Index_List : Iir_List;
       Subtype_Index_List : Iir_List;
+      Resolv_Func : Iir := Null_Iir;
+      Resolv_El : Iir := Null_Iir;
    begin
-      case Get_Kind (Type_Mark) is
-         when Iir_Kind_Array_Type_Definition
-           | Iir_Kind_Unconstrained_Array_Subtype_Definition =>
-            null;
-         when others =>
-            Error_Msg_Sem
-              (Disp_Node (Type_Mark) & " cannot be constrained", Def);
-            --  Continue as if BASE_TYPE is really a base type, it is safe.
-      end case;
+      if Resolution /= Null_Iir then
+         case Get_Kind (Resolution) is
+            when Iir_Kinds_Name =>
+               Resolv_Func := Resolution;
+            when Iir_Kind_Array_Subtype_Definition =>
+               Resolv_El := Get_Element_Subtype (Resolution);
+               Free_Iir (Resolution);
+            when Iir_Kind_Record_Subtype_Definition =>
+               Error_Msg_Sem
+                 ("record element resolution not allowed for array subtype",
+                  Resolution);
+            when others =>
+               Error_Kind ("sem_array_constraint(resolution)", Resolution);
+         end case;
+      end if;
 
-      Base_Type := Get_Base_Type (Type_Mark);
-      Set_Base_Type (Def, Base_Type);
-      El_Type := Get_Element_Subtype (Base_Type);
-      Staticness := Get_Type_Staticness (El_Type);
-      Error_Seen := False;
-      Type_Index_List := Get_Index_Subtype_List (Base_Type);
-      Subtype_Index_List := Get_Index_Subtype_List (Def);
-      for I in Natural loop
-         Type_Index := Get_Nth_Element (Type_Index_List, I);
-         Subtype_Index := Get_Nth_Element (Subtype_Index_List, I);
-         exit when Type_Index = Null_Iir and Subtype_Index = Null_Iir;
-
-         if Type_Index = Null_Iir then
-            Error_Msg_Sem ("subtype has more indexes than "
-                           & Disp_Node (Type_Mark)
-                           & " defined at " & Disp_Location (Type_Mark),
-                           Subtype_Index);
-            --  Forget extra indexes.
-            Set_Nbr_Elements (Subtype_Index_List, I);
-            exit;
-         end if;
-         if Subtype_Index = Null_Iir then
-            if not Error_Seen then
-               Error_Msg_Sem ("subtype has less indexes than "
-                              & Disp_Node (Type_Mark)
-                              & " defined at " & Disp_Location (Type_Mark),
-                              Def);
-               Error_Seen := True;
-            end if;
-            --  Use type_index as a fake subtype
-            --  FIXME: it is too fake.
-            Append_Element (Subtype_Index_List, Type_Index);
-            Staticness := None;
-         else
-            Subtype_Index := Sem_Discrete_Range_Expression
-              (Subtype_Index, Type_Index, True);
-            if Subtype_Index /= Null_Iir then
-               Subtype_Index := Range_To_Subtype_Definition (Subtype_Index);
-               Staticness := Min (Staticness,
-                                  Get_Type_Staticness (Subtype_Index));
-            end if;
-            if Subtype_Index = Null_Iir then
-               --  Create a fake subtype from type_index.
-               --  FIXME: It is too fake.
-               Subtype_Index := Type_Index;
-               Staticness := None;
-            end if;
-            Replace_Nth_Element (Subtype_Index_List, I, Subtype_Index);
+      Mark_El_Type := Get_Element_Subtype (Type_Mark);
+
+      if Def = Null_Iir then
+         Res := Copy_Subtype_Indication (Type_Mark);
+      else
+         case Get_Kind (Def) is
+            when Iir_Kind_Subtype_Definition =>
+               -- This is the case of "subtype new_array is [func] old_array".
+               -- def must be a constrained array.
+               if Get_Range_Constraint (Def) /= Null_Iir then
+                  Error_Msg_Sem
+                    ("cannot use a range constraint for array types", Def);
+                  return Type_Mark;
+               end if;
+
+               -- LRM08 6.3 Subtype declarations
+               --
+               -- If the subtype indication does not include a constraint, the
+               -- subtype is the same as that denoted by the type mark.
+               if Resolution = Null_Iir then
+                  Free_Name (Def);
+                  return Type_Mark;
+               end if;
+
+               Res := Copy_Subtype_Indication (Type_Mark);
+               Location_Copy (Res, Def);
+               Free_Name (Def);
+
+            when Iir_Kind_Array_Subtype_Definition =>
+               -- Case of a constraint for an array.
+               -- Check each index constraint against array type.
+
+               Base_Type := Get_Base_Type (Type_Mark);
+               Set_Base_Type (Def, Base_Type);
+
+               Staticness := Get_Type_Staticness (Mark_El_Type);
+               Error_Seen := False;
+               Type_Index_List := Get_Index_Subtype_List (Base_Type);
+               Subtype_Index_List := Get_Index_Subtype_List (Def);
+
+               --  LRM08 5.3.2.2
+               --  If an array constraint of the first form (including an index
+               --  constraint) applies to a type or subtype, then the type or
+               --  subtype shall be an unconstrained or partially constrained
+               --  array type with no index constraint applying to the index
+               --  subtypes, or an access type whose designated type is such
+               --  a type.
+               if Get_Kind (Type_Mark) = Iir_Kind_Array_Subtype_Definition
+                 and then Get_Index_Constraint_Flag (Type_Mark)
+               then
+                  Error_Msg_Sem ("constrained array cannot be re-constrained",
+                                 Def);
+               end if;
+               for I in Natural loop
+                  Type_Index := Get_Nth_Element (Type_Index_List, I);
+                  Subtype_Index := Get_Nth_Element (Subtype_Index_List, I);
+                  exit when Type_Index = Null_Iir and Subtype_Index = Null_Iir;
+
+                  if Type_Index = Null_Iir then
+                     Error_Msg_Sem
+                       ("subtype has more indexes than "
+                          & Disp_Node (Type_Mark)
+                          & " defined at " & Disp_Location (Type_Mark),
+                        Subtype_Index);
+                     --  Forget extra indexes.
+                     Set_Nbr_Elements (Subtype_Index_List, I);
+                     exit;
+                  end if;
+                  if Subtype_Index = Null_Iir then
+                     if not Error_Seen then
+                        Error_Msg_Sem
+                          ("subtype has less indexes than "
+                             & Disp_Node (Type_Mark)
+                             & " defined at "
+                             & Disp_Location (Type_Mark), Def);
+                        Error_Seen := True;
+                     end if;
+                     --  Use type_index as a fake subtype
+                     --  FIXME: it is too fake.
+                     Append_Element (Subtype_Index_List, Type_Index);
+                     Staticness := None;
+                  else
+                     Subtype_Index := Sem_Discrete_Range_Expression
+                       (Subtype_Index, Type_Index, True);
+                     if Subtype_Index /= Null_Iir then
+                        Subtype_Index :=
+                          Range_To_Subtype_Definition (Subtype_Index);
+                        Staticness := Min
+                          (Staticness, Get_Type_Staticness (Subtype_Index));
+                     end if;
+                     if Subtype_Index = Null_Iir then
+                        --  Create a fake subtype from type_index.
+                        --  FIXME: It is too fake.
+                        Subtype_Index := Type_Index;
+                        Staticness := None;
+                     end if;
+                     Replace_Nth_Element
+                       (Subtype_Index_List, I, Subtype_Index);
+                  end if;
+               end loop;
+               Set_Index_Constraint_Flag (Def, True);
+               Set_Type_Staticness (Def, Staticness);
+               Set_Type_Mark (Def, Type_Mark);
+               Set_Signal_Type_Flag (Def, Get_Signal_Type_Flag (Type_Mark));
+               Res := Def;
+
+            when others =>
+               --  LRM93 3.2.1.1 / LRM08 5.3.2.2
+               --  Index Constraints and Discrete Ranges
+               --
+               --  If an index constraint appears after a type mark [...]
+               --  The type mark must denote either an unconstrained array
+               --  type, or an access type whose designated type is such
+               --  an array type.
+               Error_Msg_Sem
+                 ("only unconstrained array type may be contrained "
+                    &"by index", Def);
+               Error_Msg_Sem
+                 (" (type mark is " & Disp_Node (Type_Mark) & ")",
+                  Type_Mark);
+               return Type_Mark;
+         end case;
+      end if;
+
+      --  Element subtype.
+      if Resolv_El /= Null_Iir then
+         El_Type := Sem_Subtype_Constraint (Null_Iir, Mark_El_Type, Resolv_El);
+         if El_Type = Null_Iir then
+            El_Type := Mark_El_Type;
          end if;
-      end loop;
-      Set_Type_Staticness (Def, Staticness);
-      Set_Element_Subtype (Def, El_Type);
-      Sem_Resolution_Function (Def);
-      if Get_Resolved_Flag (Def) or else Get_Resolved_Flag (El_Type) then
-         Set_Resolved_Flag (Def, True);
       else
-         Set_Resolved_Flag (Def, False);
+         El_Type := Mark_El_Type;
       end if;
-      Set_Type_Mark (Def, Type_Mark);
-      Set_Signal_Type_Flag (Def, Get_Signal_Type_Flag (Type_Mark));
-      return Def;
-   end Sem_Array_Subtype_Indication;
+      Set_Element_Subtype (Res, El_Type);
 
-   --  Semantize a subtype indication.
-   --  DEF can be either a name or an iir_subtype_definition.
-   --  Return a new (an anonymous) subtype definition (with the correct kind),
-   --  or an already defined type definition (if DEF is a name).
-   function Sem_Subtype_Indication (Def: Iir; Incomplete : Boolean := False)
-     return Iir
+      Set_Constraint_State (Res, Get_Array_Constraint (Res));
+
+      if Resolv_Func /= Null_Iir then
+         Sem_Resolution_Function (Resolv_Func, Res);
+      elsif Get_Kind (Type_Mark) = Iir_Kind_Array_Subtype_Definition then
+         Set_Resolution_Function (Res, Get_Resolution_Function (Type_Mark));
+      end if;
+      if Get_Resolved_Flag (Res)
+        or else Get_Resolved_Flag (Get_Element_Subtype (Type_Mark))
+      then
+         Set_Resolved_Flag (Res, True);
+      else
+         Set_Resolved_Flag (Res, False);
+      end if;
+
+      return Res;
+   end Sem_Array_Constraint;
+
+   function Reparse_As_Record_Element_Constraint (Name : Iir) return Iir
    is
-      Type_Mark: Iir;
-      Res: Iir;
-      Decl_Kind : Decl_Kind_Type;
+      Prefix : Iir;
+      Parent : Iir;
+      El : Iir;
    begin
-      if Incomplete then
-         Decl_Kind := Decl_Incomplete_Type;
+      if Get_Kind (Name) /= Iir_Kind_Parenthesis_Name then
+         Error_Msg_Sem ("record element constraint expected", Name);
+         return Null_Iir;
       else
-         Decl_Kind := Decl_Type;
+         Prefix := Get_Prefix (Name);
+         Parent := Name;
+         while Get_Kind (Prefix) = Iir_Kind_Parenthesis_Name loop
+            Parent := Prefix;
+            Prefix := Get_Prefix (Prefix);
+         end loop;
+         if Get_Kind (Prefix) /= Iir_Kind_Simple_Name then
+            Error_Msg_Sem ("record element name must be a simple name",
+                           Prefix);
+            return Null_Iir;
+         else
+            El := Create_Iir (Iir_Kind_Record_Element_Constraint);
+            Location_Copy (El, Prefix);
+            Set_Identifier (El, Get_Identifier (Prefix));
+            Set_Type (El, Name);
+            Set_Prefix (Parent, Null_Iir);
+            Free_Name (Prefix);
+            return El;
+         end if;
       end if;
+   end Reparse_As_Record_Element_Constraint;
 
-      -- Simple case that correspond to no indication except a subtype
-      -- identifier
-      if Get_Kind (Def) in Iir_Kinds_Name then
-         Type_Mark := Find_Declaration (Def, Decl_Kind);
-         if Type_Mark = Null_Iir then
-            return Create_Error_Type (Def);
+   function Reparse_As_Record_Constraint (Def : Iir) return Iir
+   is
+      Res : Iir;
+      Chain : Iir;
+      El_List : Iir_List;
+      El : Iir;
+   begin
+      if Get_Prefix (Def) /= Null_Iir then
+         raise Internal_Error;
+      end if;
+      Res := Create_Iir (Iir_Kind_Record_Subtype_Definition);
+      Location_Copy (Res, Def);
+      El_List := Create_Iir_List;
+      Set_Elements_Declaration_List (Res, El_List);
+      Chain := Get_Association_Chain (Def);
+      while Chain /= Null_Iir loop
+         if Get_Kind (Chain) /= Iir_Kind_Association_Element_By_Expression
+           or else Get_Formal (Chain) /= Null_Iir
+         then
+            Error_Msg_Sem ("badly formed record constraint", Chain);
          else
-            return Type_Mark;
+            El := Reparse_As_Record_Element_Constraint (Get_Actual (Chain));
+            if El /= Null_Iir then
+               Append_Element (El_List, El);
+            end if;
          end if;
+         Chain := Get_Chain (Chain);
+      end loop;
+      return Res;
+   end Reparse_As_Record_Constraint;
+
+   function Reparse_As_Array_Constraint (Def : Iir; Def_Type : Iir) return Iir
+   is
+      Parent : Iir;
+      Name : Iir;
+      Prefix : Iir;
+      Res : Iir;
+      Chain : Iir;
+      El_List : Iir_List;
+      Def_El_Type : Iir;
+   begin
+      Name := Def;
+      Prefix := Get_Prefix (Name);
+      Parent := Null_Iir;
+      while Prefix /= Null_Iir
+        and then Get_Kind (Prefix) = Iir_Kind_Parenthesis_Name
+      loop
+         Parent := Name;
+         Name := Prefix;
+         Prefix := Get_Prefix (Name);
+      end loop;
+      --  Detach prefix.
+      if Parent /= Null_Iir then
+         Set_Prefix (Parent, Null_Iir);
+      end if;
+      Res := Create_Iir (Iir_Kind_Array_Subtype_Definition);
+      Location_Copy (Res, Name);
+      Chain := Get_Association_Chain (Name);
+      if Get_Kind (Chain) = Iir_Kind_Association_Element_Open then
+         if Get_Chain (Chain) /= Null_Iir then
+            Error_Msg_Sem ("'open' must be alone", Chain);
+         end if;
+      else
+         El_List := Create_Iir_List;
+         Set_Index_Subtype_List (Res, El_List);
+         while Chain /= Null_Iir loop
+            if Get_Kind (Chain) /= Iir_Kind_Association_Element_By_Expression
+              or else Get_Formal (Chain) /= Null_Iir
+            then
+               Error_Msg_Sem ("bad form of array constraint", Chain);
+            else
+               Append_Element (El_List, Get_Actual (Chain));
+            end if;
+            Chain := Get_Chain (Chain);
+         end loop;
       end if;
 
-      --  Semantize the type mark.
-      Type_Mark := Find_Declaration (Get_Type_Mark (Def), Decl_Kind);
-      if Type_Mark = Null_Iir then
-         --  FIXME: handle inversion such as "subtype BASETYPE RESOLV", which
-         --  should emit "resolution function must precede type name".
-         return Create_Error_Type (Get_Type_Mark (Def));
+      Def_El_Type := Get_Element_Subtype (Def_Type);
+      if Parent /= Null_Iir then
+         case Get_Kind (Def_El_Type) is
+            when Iir_Kinds_Array_Type_Definition =>
+               Set_Element_Subtype
+                 (Res, Reparse_As_Array_Constraint (Def, Def_El_Type));
+            when others =>
+               Error_Kind ("reparse_as_array_constraint", Def_El_Type);
+         end case;
+      end if;
+      return Res;
+   end Reparse_As_Array_Constraint;
+
+   function Sem_Record_Constraint
+     (Def : Iir; Type_Mark : Iir; Resolution : Iir)
+     return Iir
+   is
+      Res : Iir;
+      El_List, Tm_El_List : Iir_List;
+      El : Iir;
+      Tm_El : Iir;
+      Tm_El_Type : Iir;
+      El_Type : Iir;
+      Res_List : Iir_List;
+
+      Index_List : Iir_List;
+      Index_El : Iir;
+   begin
+      Res := Create_Iir (Iir_Kind_Record_Subtype_Definition);
+      Location_Copy (Res, Def);
+      Set_Base_Type (Res, Type_Mark);
+      Set_Type_Staticness (Res, Get_Type_Staticness (Type_Mark));
+      Set_Type_Mark (Res, Type_Mark);
+      if Get_Kind (Type_Mark) = Iir_Kind_Record_Subtype_Definition then
+         Set_Resolution_Function (Res, Get_Resolution_Function (Type_Mark));
       end if;
-      Set_Type_Mark (Def, Type_Mark);
 
-      --  Check constraint.
       case Get_Kind (Def) is
-         when Iir_Kind_Array_Subtype_Definition =>
-            case Get_Kind (Type_Mark) is
-               when Iir_Kind_Unconstrained_Array_Subtype_Definition
-                 | Iir_Kind_Array_Type_Definition
-                 | Iir_Kind_Access_Type_Definition =>
-                  null;
-               when others =>
-                  --  LRM 3.2.1.1  Index Constraints and Discrete Ranges
-                  --  If an index constraint appears after a type mark [...]
-                  --  The type mark must denote either an unconstrained array
-                  --  type, or an access type whose designated type is such
-                  --  an array type.
-                  Error_Msg_Sem
-                    ("only unconstrained array type may be contrained "
-                     &"by index", Def);
-                  Error_Msg_Sem
-                    (" (type mark is " & Disp_Node (Type_Mark) & ")",
-                     Type_Mark);
-                  return Type_Mark;
-            end case;
          when Iir_Kind_Subtype_Definition =>
-            case Get_Kind (Type_Mark) is
-               when Iir_Kind_Integer_Subtype_Definition
-                 | Iir_Kind_Floating_Subtype_Definition
-                 | Iir_Kind_Enumeration_Subtype_Definition
-                 | Iir_Kind_Physical_Subtype_Definition =>
-                  null;
-               when Iir_Kind_Enumeration_Type_Definition =>
-                  null;
-               when others =>
-                  --  FIXME: find the correct sentence from LRM
-                  --  GHDL: subtype_definition may also be used just to add
-                  --    a resolution function.
-                  if Get_Range_Constraint (Def) /= Null_Iir then
-                     Error_Msg_Sem
-                       ("only scalar types may be constrained by range", Def);
-                     Error_Msg_Sem
-                       (" (type mark is " & Disp_Node (Type_Mark) & ")",
-                        Type_Mark);
-                     return Type_Mark;
-                  end if;
-            end case;
+            Free_Name (Def);
+            Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Type_Mark));
+            Set_Constraint_State (Res, Get_Constraint_State (Type_Mark));
+            El_List := Null_Iir_List;
+
+         when Iir_Kind_Array_Subtype_Definition =>
+            --  Record constraints are parsed as array constraints.
+            if Get_Kind (Def) /= Iir_Kind_Array_Subtype_Definition then
+               raise Internal_Error;
+            end if;
+            Index_List := Get_Index_Subtype_List (Def);
+            El_List := Create_Iir_List;
+            Set_Elements_Declaration_List (Res, El_List);
+            for I in Natural loop
+               Index_El := Get_Nth_Element (Index_List, I);
+               exit when Index_El = Null_Iir;
+               El := Reparse_As_Record_Element_Constraint (Index_El);
+               if El /= Null_Iir then
+                  Append_Element (El_List, El);
+               end if;
+            end loop;
+
+         when Iir_Kind_Record_Subtype_Definition =>
+            El_List := Get_Elements_Declaration_List (Def);
+            Set_Elements_Declaration_List (Res, El_List);
+
          when others =>
-            Error_Kind ("sem_subtype_indication", Def);
+            Error_Kind ("sem_record_constraint", Def);
       end case;
 
-      case Get_Kind (Type_Mark) is
-         when Iir_Kind_Array_Subtype_Definition
-           | Iir_Kind_Array_Type_Definition
-           | Iir_Kind_Unconstrained_Array_Subtype_Definition =>
---             --  If the base type is an unconstrained array subtype, then get
---            --  the *real* base type, and copy the resolution function (since
---             --  a base type has no resolution function).
---             if Get_Kind (Type_Mark) =
---               Iir_Kind_Unconstrained_Array_Subtype_Definition
---               and then Get_Kind (Def) = Iir_Kind_Subtype_Definition
---             then
---                if Get_Resolution_Function (Def) = Null_Iir then
---                   if Get_Range_Constraint (Def) = Null_Iir then
---                      --  In this case, DEF must simply be a name.  There is
---                      --  a parser internal error.
---                      raise Internal_Error;
---                   end if;
---                   Set_Resolution_Function
---                     (Def, Get_Resolution_Function (Type_Mark));
---                end if;
---             end if;
-
-            if Get_Kind (Def) = Iir_Kind_Subtype_Definition then
-               -- This is the case of "subtype new_array is [func] old_array".
-               -- def must be a constrained array.
-               if Get_Range_Constraint (Def) /= Null_Iir then
-                  Error_Msg_Sem
-                    ("cannot use a range constraint for an array", Def);
-                  return Type_Mark;
-               end if;
-               if Get_Resolution_Function (Def) = Null_Iir then
-                  --  In this case, DEF must simply be a name.  There is
-                  --  a parser internal error.
-                  raise Internal_Error;
-               end if;
-               case Get_Kind (Type_Mark) is
-                  when Iir_Kind_Array_Type_Definition =>
-                     Res := Create_Iir
-                       (Iir_Kind_Unconstrained_Array_Subtype_Definition);
-                  when Iir_Kind_Array_Subtype_Definition =>
-                     Res := Create_Iir (Iir_Kind_Array_Subtype_Definition);
-                     Set_Element_Subtype
-                       (Res, Get_Element_Subtype (Type_Mark));
-                     Set_Index_Subtype_List
-                       (Res, Get_Index_Subtype_List (Type_Mark));
-                  when others =>
-                     Error_Kind ("sem_subtype_indication(array)", Type_Mark);
-               end case;
-               Location_Copy (Res, Def);
-               Set_Base_Type (Res, Get_Base_Type (Type_Mark));
-               Set_Resolution_Function (Res, Get_Resolution_Function (Def));
-               Set_Type_Staticness (Res, Get_Type_Staticness (Type_Mark));
-               Sem_Resolution_Function (Res);
-               Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Type_Mark));
-               if Get_Resolved_Flag (Res)
-                 or else Get_Resolved_Flag (Get_Element_Subtype (Type_Mark))
-               then
-                  Set_Resolved_Flag (Res, True);
-               else
-                  Set_Resolved_Flag (Res, False);
-               end if;
-               Set_Type_Mark (Res, Type_Mark);
-               Free_Name (Def);
-               return Res;
-            elsif Get_Kind (Def) = Iir_Kind_Array_Subtype_Definition then
-               -- Case of a constraint for an array.
-               -- Check each index constraint against array type.
-               return Sem_Array_Subtype_Indication (Type_Mark, Def);
-            else
-               Error_Kind ("sem_subtype_indication(1)", Def);
-               return Type_Mark;
+      Res_List := Null_Iir_List;
+      if Resolution /= Null_Iir then
+         case Get_Kind (Resolution) is
+            when Iir_Kinds_Name =>
+               null;
+            when Iir_Kind_Record_Subtype_Definition =>
+               Res_List := Get_Elements_Declaration_List (Resolution);
+            when Iir_Kind_Array_Subtype_Definition =>
+               Error_Msg_Sem
+                 ("resolution indication must be an array element resolution",
+                  Resolution);
+            when others =>
+               Error_Kind ("sem_record_constraint(resolution)", Resolution);
+         end case;
+      end if;
+
+      Tm_El_List := Get_Elements_Declaration_List (Type_Mark);
+      if El_List /= Null_Iir_List or Res_List /= Null_Iir_List then
+         declare
+            Nbr_Els : constant Natural := Get_Nbr_Elements (Tm_El_List);
+            Els : Iir_Array (0 .. Nbr_Els - 1) := (others => Null_Iir);
+            Res_Els : Iir_Array (0 .. Nbr_Els - 1) := (others => Null_Iir);
+            Pos : Natural;
+            Constraint : Iir_Constraint;
+         begin
+            --  Fill ELS.
+            if El_List /= Null_Iir_List then
+               for I in Natural loop
+                  El := Get_Nth_Element (El_List, I);
+                  exit when El = Null_Iir;
+                  Tm_El := Find_Name_In_List (Tm_El_List, Get_Identifier (El));
+                  if Tm_El = Null_Iir then
+                     Error_Msg_Sem (Disp_Node (Type_Mark)
+                                      & "has no " & Disp_Node (El), El);
+                  else
+                     Set_Element_Declaration (El, Tm_El);
+                     Pos := Natural (Get_Element_Position (Tm_El));
+                     if Els (Pos) /= Null_Iir then
+                        Error_Msg_Sem
+                          (Disp_Node (El) & " was already constrained", El);
+                        Error_Msg_Sem
+                          (" (location of previous constrained)", Els (Pos));
+                     else
+                        Els (Pos) := El;
+                        Set_Parent (El, Res);
+                     end if;
+                     El_Type := Get_Type (El);
+                     Tm_El_Type := Get_Type (Tm_El);
+                     if Get_Kind (El_Type) = Iir_Kind_Parenthesis_Name then
+                        case Get_Kind (Tm_El_Type) is
+                           when Iir_Kinds_Array_Type_Definition =>
+                              El_Type := Reparse_As_Array_Constraint
+                                (El_Type, Tm_El_Type);
+                           when Iir_Kind_Record_Type_Definition
+                             | Iir_Kind_Record_Subtype_Definition =>
+                              El_Type := Reparse_As_Record_Constraint
+                                (El_Type);
+                           when others =>
+                              Error_Msg_Sem
+                                ("only composite types may be constrained",
+                                 El_Type);
+                        end case;
+                     end if;
+                     Set_Type (El, El_Type);
+                  end if;
+               end loop;
+               Destroy_Iir_List (El_List);
             end if;
 
-         when Iir_Kind_Integer_Subtype_Definition
-           | Iir_Kind_Floating_Subtype_Definition
-           | Iir_Kind_Enumeration_Subtype_Definition
-           | Iir_Kind_Physical_Subtype_Definition =>
-            if Get_Range_Constraint (Def) = Null_Iir
-              and then Get_Resolution_Function (Def) = Null_Iir
-            then
-               --  This defines an alias, and must have been handled just
-               --  before the case statment.
-               raise Internal_Error;
+            --  Fill Res_Els.
+            if Res_List /= Null_Iir_List then
+               for I in Natural loop
+                  El := Get_Nth_Element (Res_List, I);
+                  exit when El = Null_Iir;
+                  Tm_El := Find_Name_In_List (Tm_El_List, Get_Identifier (El));
+                  if Tm_El = Null_Iir then
+                     Error_Msg_Sem (Disp_Node (Type_Mark)
+                                      & "has no " & Disp_Node (El), El);
+                  else
+                     Pos := Natural (Get_Element_Position (Tm_El));
+                     if Res_Els (Pos) /= Null_Iir then
+                        Error_Msg_Sem
+                          (Disp_Node (El) & " was already resolved", El);
+                        Error_Msg_Sem
+                          (" (location of previous constrained)", Els (Pos));
+                     else
+                        Res_Els (Pos) := Get_Element_Declaration (El);
+                     end if;
+                  end if;
+                  --Free_Iir (El);
+               end loop;
+               Destroy_Iir_List (Res_List);
             end if;
-            declare
-               A_Range : Iir;
-            begin
-               -- There are limits.  Create a new subtype.
-               Res := Create_Iir (Get_Kind (Type_Mark));
-               Location_Copy (Res, Def);
-               Set_Base_Type (Res, Get_Base_Type (Type_Mark));
-               Set_Type_Mark (Res, Type_Mark);
-               Set_Resolution_Function (Res, Get_Resolution_Function (Def));
-               A_Range := Get_Range_Constraint (Def);
-               if A_Range = Null_Iir then
-                  A_Range := Get_Range_Constraint (Type_Mark);
+
+            --  Build elements list.
+            El_List := Create_Iir_List;
+            Set_Elements_Declaration_List (Res, El_List);
+            Constraint := Fully_Constrained;
+            for I in Els'Range loop
+               Tm_El := Get_Nth_Element (Tm_El_List, I);
+               if Els (I) = Null_Iir and Res_Els (I) = Null_Iir then
+                  El := Tm_El;
                else
-                  A_Range := Sem_Discrete_Range_Expression
-                    (A_Range, Type_Mark, True);
-                  if A_Range = Null_Iir then
-                     --  Avoid error propagation.
-                     A_Range := Get_Range_Constraint (Type_Mark);
+                  if Els (I) = Null_Iir then
+                     El := Create_Iir (Iir_Kind_Record_Element_Constraint);
+                     Location_Copy (El, Tm_El);
+                     Set_Element_Declaration (El, Tm_El);
+                     Set_Element_Position (El, Get_Element_Position (Tm_El));
+                     El_Type := Null_Iir;
+                  else
+                     El := Els (I);
+                     El_Type := Get_Type (El);
                   end if;
+                  El_Type := Sem_Subtype_Constraint (El_Type,
+                                                     Get_Type (Tm_El),
+                                                     Res_Els (I));
+                  Set_Type (El, El_Type);
                end if;
-               Set_Range_Constraint (Res, A_Range);
-               Set_Type_Staticness (Res, Get_Expr_Staticness (A_Range));
-               Free_Name (Def);
-               Sem_Resolution_Function (Res);
-               Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Type_Mark));
-               return Res;
-            end;
+               Append_Element (El_List, El);
+               Constraint := Update_Record_Constraint
+                 (Constraint, Get_Type (El));
+            end loop;
+            Set_Constraint_State (Res, Constraint);
+         end;
+      else
+         Set_Elements_Declaration_List (Res, Tm_El_List);
+         Set_Constraint_State (Res, Get_Constraint_State (Type_Mark));
+      end if;
 
-         when Iir_Kind_Enumeration_Type_Definition =>
-            if Get_Range_Constraint (Def) = Null_Iir and then
-              Get_Resolution_Function (Def) = Null_Iir
-            then
-               raise Internal_Error;
-            end if;
+      Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Type_Mark));
 
-            declare
-               Constraint : Iir_Range_Expression;
-            begin
-               -- There are limits.  Create a new subtype.
-               Res := Create_Iir (Iir_Kind_Enumeration_Subtype_Definition);
-               Location_Copy (Res, Def);
-               Set_Base_Type (Res, Type_Mark);
-               Set_Type_Mark (Res, Type_Mark);
-               Set_Resolution_Function (Res, Get_Resolution_Function (Def));
-               Constraint := Get_Range_Constraint (Def);
-               if Constraint = Null_Iir then
-                  Constraint := Get_Range_Constraint (Type_Mark);
-               else
-                  Constraint := Sem_Discrete_Range_Expression
-                    (Constraint, Type_Mark, True);
-                  -- FIXME: check bounds, check static
-               end if;
-               Set_Range_Constraint (Res, Constraint);
-               Set_Type_Staticness (Res, Get_Expr_Staticness (Constraint));
-            end;
-            Free_Name (Def);
-            Sem_Resolution_Function (Res);
-            Set_Signal_Type_Flag (Res, True);
-            return Res;
+      if Resolution /= Null_Iir
+        and then Get_Kind (Resolution) in Iir_Kinds_Name
+      then
+         Sem_Resolution_Function (Resolution, Res);
+      end if;
 
-         when Iir_Kind_Record_Type_Definition =>
-            declare
-               Func: Iir;
-            begin
-               if Get_Kind (Def) /= Iir_Kind_Subtype_Definition then
-                  Error_Kind ("sem_subtype_indication1", Def);
-                  return Null_Iir;
-               end if;
-               Func := Get_Resolution_Function (Def);
-               if Func = Null_Iir then
-                  --  This is an alias.
-                  raise Internal_Error;
-               end if;
-               Res := Create_Iir (Iir_Kind_Record_Subtype_Definition);
-               Location_Copy (Res, Def);
-               Set_Base_Type (Res, Type_Mark);
-               Set_Type_Staticness (Res, Get_Type_Staticness (Type_Mark));
-               Set_Type_Mark (Res, Type_Mark);
-               Set_Resolution_Function (Res, Func);
-               Sem_Resolution_Function (Res);
-               Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Type_Mark));
-               Free_Name (Def);
-               return Res;
-            end;
+      return Res;
+   end Sem_Record_Constraint;
 
-         when Iir_Kind_Access_Type_Definition =>
+   function Sem_Range_Constraint (Def : Iir; Type_Mark : Iir; Resolution : Iir)
+                                 return Iir
+   is
+      Res : Iir;
+      A_Range : Iir;
+   begin
+      if Def = Null_Iir then
+         Res := Copy_Subtype_Indication (Type_Mark);
+      else
+         if Get_Kind (Def) /= Iir_Kind_Subtype_Definition then
+            --  FIXME: find the correct sentence from LRM
+            --  GHDL: subtype_definition may also be used just to add
+            --    a resolution function.
+            Error_Msg_Sem
+              ("only scalar types may be constrained by range", Def);
+            Error_Msg_Sem
+              (" (type mark is " & Disp_Node (Type_Mark) & ")",
+               Type_Mark);
+            return Type_Mark;
+         end if;
+
+         if Get_Range_Constraint (Def) = Null_Iir
+           and then Resolution = Null_Iir
+         then
+            --  This defines an alias, and must have been handled just
+            --  before the case statment.
+            raise Internal_Error;
+         end if;
+
+         -- There are limits.  Create a new subtype.
+         if Get_Kind (Type_Mark) = Iir_Kind_Enumeration_Type_Definition then
+            Res := Create_Iir (Iir_Kind_Enumeration_Subtype_Definition);
+         else
+            Res := Create_Iir (Get_Kind (Type_Mark));
+         end if;
+         Location_Copy (Res, Def);
+         Set_Base_Type (Res, Get_Base_Type (Type_Mark));
+         Set_Type_Mark (Res, Type_Mark);
+         Set_Resolution_Function (Res, Get_Resolution_Function (Def));
+         A_Range := Get_Range_Constraint (Def);
+         if A_Range = Null_Iir then
+            A_Range := Get_Range_Constraint (Type_Mark);
+         else
+            A_Range := Sem_Discrete_Range_Expression
+              (A_Range, Type_Mark, True);
+            if A_Range = Null_Iir then
+               --  Avoid error propagation.
+               A_Range := Get_Range_Constraint (Type_Mark);
+            end if;
+         end if;
+         Set_Range_Constraint (Res, A_Range);
+         Set_Type_Staticness (Res, Get_Expr_Staticness (A_Range));
+         Free_Name (Def);
+         Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Type_Mark));
+      end if;
+
+      if Resolution /= Null_Iir then
+         --  LRM08 6.3  Subtype declarations.
+         if Get_Kind (Resolution) not in Iir_Kinds_Name then
+            Error_Msg_Sem ("resolution indication must be a function name",
+                           Resolution);
+         else
+            Sem_Resolution_Function (Resolution, Res);
+         end if;
+      end if;
+      return Res;
+   end Sem_Range_Constraint;
+
+   function Sem_Subtype_Constraint
+     (Def : Iir; Type_Mark : Iir; Resolution : Iir)
+     return Iir
+   is
+   begin
+      case Get_Kind (Type_Mark) is
+         when Iir_Kind_Array_Subtype_Definition
+           | Iir_Kind_Array_Type_Definition =>
+            return Sem_Array_Constraint (Def, Type_Mark, Resolution);
+         when Iir_Kind_Integer_Subtype_Definition
+           | Iir_Kind_Floating_Subtype_Definition
+           | Iir_Kind_Enumeration_Subtype_Definition
+           | Iir_Kind_Physical_Subtype_Definition
+           | Iir_Kind_Enumeration_Type_Definition=>
+            return Sem_Range_Constraint (Def, Type_Mark, Resolution);
+         when Iir_Kind_Record_Type_Definition
+           | Iir_Kind_Record_Subtype_Definition =>
+            return Sem_Record_Constraint (Def, Type_Mark, Resolution);
+         when Iir_Kind_Access_Type_Definition
+           | Iir_Kind_Access_Subtype_Definition =>
             --  LRM93 4.2
             --  A subtype indication denoting an access type [or a file type]
             --  may not contain a resolution function.
-            if Get_Resolution_Function (Def) /= Null_Iir then
+            if Resolution /= Null_Iir then
                Error_Msg_Sem
                  ("resolution function not allowed for an access type", Def);
             end if;
@@ -1491,9 +1826,11 @@ package body Sem_Types is
                      Sub_Type : Iir;
                      pragma Unreferenced (Sub_Type);
                      Base_Type : Iir;
+                     Res : Iir;
                   begin
                      Base_Type := Get_Designated_Type (Type_Mark);
-                     Sub_Type := Sem_Array_Subtype_Indication (Base_Type, Def);
+                     Sub_Type := Sem_Array_Constraint
+                       (Def, Base_Type, Null_Iir);
                      Res := Create_Iir (Iir_Kind_Access_Subtype_Definition);
                      Location_Copy (Res, Def);
                      Set_Base_Type (Res, Type_Mark);
@@ -1506,50 +1843,157 @@ package body Sem_Types is
             end case;
 
          when Iir_Kind_File_Type_Definition =>
-            if Get_Kind (Def) = Iir_Kind_Subtype_Definition then
-               Free_Name (Def);
+            --  LRM08 6.3 Subtype declarations
+            --  A subtype indication denoting a subtype of [...] a file
+            --  type [...] shall not contain a constraint.
+            if Get_Kind (Def) /= Iir_Kind_Subtype_Definition
+              or else Get_Range_Constraint (Def) /= Null_Iir
+            then
+               Error_Msg_Sem ("file types can't be constrained", Def);
+               return Type_Mark;
+            end if;
+
+            --  LRM93 4.2
+            --  A subtype indication denoting [an access type or] a file type
+            --  may not contain a resolution function.
+            if Resolution /= Null_Iir then
+               Error_Msg_Sem
+                 ("resolution function not allowed for file types", Def);
+               return Type_Mark;
+            end if;
+            Free_Name (Def);
+            return Type_Mark;
+
+         when Iir_Kind_Protected_Type_Declaration =>
+            --  LRM08 6.3 Subtype declarations
+            --  A subtype indication denoting a subtype of [...] a protected
+            --  type [...] shall not contain a constraint.
+            if Get_Kind (Def) /= Iir_Kind_Subtype_Definition
+              or else Get_Range_Constraint (Def) /= Null_Iir
+            then
+               Error_Msg_Sem ("protected types can't be constrained", Def);
+               return Type_Mark;
+            end if;
+
+            --  LRM08 6.3 Subtype declarations
+            --  A subtype indication denoting [...] a protected type shall
+            --  not contain a resolution function.
+            if Resolution /= Null_Iir then
+               Error_Msg_Sem
+                 ("resolution function not allowed for file types", Def);
                return Type_Mark;
-            else
-               raise Internal_Error;
             end if;
+            Free_Name (Def);
+            return Type_Mark;
 
          when others =>
             Error_Kind ("sem_subtype_indication", Type_Mark);
-            return Def;
+            return Type_Mark;
       end case;
+   end Sem_Subtype_Constraint;
+
+   --  Semantize a subtype indication.
+   --  DEF can be either a name or an iir_subtype_definition.
+   --  Return a new (an anonymous) subtype definition (with the correct kind),
+   --  or an already defined type definition (if DEF is a name).
+   function Sem_Subtype_Indication (Def: Iir; Incomplete : Boolean := False)
+     return Iir
+   is
+      Type_Mark: Iir;
+      Decl_Kind : Decl_Kind_Type;
+   begin
+      if Incomplete then
+         Decl_Kind := Decl_Incomplete_Type;
+      else
+         Decl_Kind := Decl_Type;
+      end if;
+
+      -- LRM08 6.3 Subtype declarations
+      --
+      -- If the subtype indication does not include a constraint, the subtype
+      -- is the same as that denoted by the type mark.
+      if Get_Kind (Def) in Iir_Kinds_Name then
+         Type_Mark := Find_Declaration (Def, Decl_Kind);
+         if Type_Mark = Null_Iir then
+            return Create_Error_Type (Def);
+         else
+            return Type_Mark;
+         end if;
+      end if;
+
+      --  Semantize the type mark.
+      Type_Mark := Find_Declaration (Get_Type_Mark (Def), Decl_Kind);
+      if Type_Mark = Null_Iir then
+         --  FIXME: handle inversion such as "subtype BASETYPE RESOLV", which
+         --  should emit "resolution function must precede type name".
+         return Create_Error_Type (Get_Type_Mark (Def));
+      end if;
+      Set_Type_Mark (Def, Type_Mark);
+
+      return Sem_Subtype_Constraint
+        (Def, Type_Mark, Get_Resolution_Function (Def));
    end Sem_Subtype_Indication;
 
-   function Sem_Is_Constrained (A_Type: Iir) return Boolean is
+   function Copy_Subtype_Indication (Def : Iir) return Iir
+   is
+      Res : Iir;
    begin
-      case Get_Kind (A_Type) is
-         when Iir_Kind_Array_Subtype_Definition =>
-            return True;
-         when Iir_Kind_Enumeration_Subtype_Definition
-           | Iir_Kind_Enumeration_Type_Definition
-           | Iir_Kind_Integer_Subtype_Definition
-           | Iir_Kind_Integer_Type_Definition
+      case Get_Kind (Def) is
+         when Iir_Kind_Integer_Subtype_Definition
            | Iir_Kind_Floating_Subtype_Definition
-           | Iir_Kind_Floating_Type_Definition
-           | Iir_Kind_Access_Type_Definition
-           | Iir_Kind_Access_Subtype_Definition
-           | Iir_Kind_Physical_Subtype_Definition
-           | Iir_Kind_Record_Type_Definition
-           | Iir_Kind_Record_Subtype_Definition
-           | Iir_Kind_File_Type_Definition =>
-            --| Iir_Kind_File_Subtype_Definition =>
-            return True;
-         when Iir_Kind_Protected_Type_Declaration =>
-            return True;
-         when Iir_Kind_Array_Type_Definition
-           | Iir_Kind_Unconstrained_Array_Subtype_Definition =>
-            return False;
-         when Iir_Kind_Incomplete_Type_Definition =>
-            return False;
-         when Iir_Kind_Error =>
-            return True;
+           | Iir_Kind_Enumeration_Subtype_Definition
+           | Iir_Kind_Physical_Subtype_Definition =>
+            Res := Create_Iir (Get_Kind (Def));
+            Set_Range_Constraint (Res, Get_Range_Constraint (Def));
+            Set_Resolution_Function (Res, Get_Resolution_Function (Def));
+         when Iir_Kind_Enumeration_Type_Definition =>
+            Res := Create_Iir (Iir_Kind_Enumeration_Subtype_Definition);
+            Set_Type_Mark (Res, Def);
+            Set_Range_Constraint (Res, Get_Range_Constraint (Def));
+
+         when Iir_Kind_Access_Subtype_Definition
+           | Iir_Kind_Access_Type_Definition =>
+            Res := Create_Iir (Iir_Kind_Access_Subtype_Definition);
+
+         when Iir_Kind_Array_Type_Definition =>
+            Res := Create_Iir (Iir_Kind_Array_Subtype_Definition);
+            Set_Type_Staticness (Res, Get_Type_Staticness (Def));
+            Set_Resolved_Flag (Res, Get_Resolved_Flag (Def));
+            Set_Type_Mark (Res, Def);
+            Set_Index_Subtype_List (Res, Get_Index_Subtype_List (Def));
+            Set_Element_Subtype (Res, Get_Element_Subtype (Def));
+            Set_Index_Constraint_Flag (Res, False);
+            Set_Constraint_State (Res, Get_Constraint_State (Def));
+         when Iir_Kind_Array_Subtype_Definition =>
+            Res := Create_Iir (Iir_Kind_Array_Subtype_Definition);
+            Set_Resolution_Function (Res, Get_Resolution_Function (Def));
+            Set_Resolved_Flag (Res, Get_Resolved_Flag (Def));
+            Set_Type_Mark (Res, Def);
+            Set_Index_Subtype_List (Res, Get_Index_Subtype_List (Def));
+            Set_Element_Subtype (Res, Get_Element_Subtype (Def));
+            Set_Index_Constraint_Flag
+              (Res, Get_Index_Constraint_Flag (Def));
+            Set_Constraint_State (Res, Get_Constraint_State (Def));
+
+         when Iir_Kind_Record_Type_Definition
+           | Iir_Kind_Record_Subtype_Definition =>
+            Res := Create_Iir (Iir_Kind_Record_Subtype_Definition);
+            Set_Type_Staticness (Res, Get_Type_Staticness (Def));
+            if Get_Kind (Def) /= Iir_Kind_Record_Type_Definition then
+               Set_Resolution_Function
+                 (Res, Get_Resolution_Function (Def));
+            end if;
+            Set_Resolved_Flag (Res, Get_Resolved_Flag (Def));
+            Set_Constraint_State (Res, Get_Constraint_State (Def));
+
          when others =>
-            Error_Kind ("sem_is_constrained", A_Type);
+            --  FIXME: todo
+            Error_Kind ("copy_subtype_indication", Def);
       end case;
-   end Sem_Is_Constrained;
-
+      Location_Copy (Res, Def);
+      Set_Base_Type (Res, Get_Base_Type (Def));
+      Set_Type_Staticness (Res, Get_Type_Staticness (Def));
+      Set_Signal_Type_Flag (Res, Get_Signal_Type_Flag (Def));
+      return Res;
+   end Copy_Subtype_Indication;
 end Sem_Types;